{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<i>Copyright (c) Microsoft Corporation.</i>\n",
    "\n",
    "<i>Licensed under the MIT License.</i>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ARIMA: Autoregressive Integrated Moving Average\n",
    "\n",
    "This notebook provides an example of how to train an ARIMA model to generate point forecasts of product sales in retail. We will train an ARIMA based model on the Orange Juice dataset.\n",
    "\n",
    "An ARIMA, which stands for AutoRegressive Integrated Moving Average, model can be created using an `ARIMA(p,d,q)` model within `statsmodels` library. In this notebook, we will be using an alternative library `pmdarima`, which allows us to automatically search for optimal ARIMA parameters, within a specified range. More specifically, we will be using `auto_arima` function within `pmdarima` to automatically discover the optimal parameters for an ARIMA model. This function wraps `ARIMA` and `SARIMAX` models of `statsmodels` library, that correspond to non-seasonal and seasonal model space, respectively.\n",
    "\n",
    "In an ARIMA model there are 3 parameters that are used to help model the major aspects of a times series: seasonality, trend, and noise. These parameters are:\n",
    "- **p** is the parameter associated with the auto-regressive aspect of the model, which incorporates past values.\n",
    "- **d** is the parameter associated with the integrated part of the model, which effects the amount of differencing to apply to a time series.\n",
    "- **q** is the parameter associated with the moving average part of the model.,\n",
    "\n",
    "If our data has a seasonal component, we use a seasonal ARIMA model or `ARIMA(p,d,q)(P,D,Q)m`. In that case, we have an additional set of parameters: `P`, `D`, and `Q` which describe the autoregressive, differencing, and moving average terms for the seasonal part of the ARIMA model, and `m` refers to the number of periods in each season.\n",
    "\n",
    "We provide a [quick-start ARIMA example](../00_quick_start/auto_arima_forecasting.ipynb), in which we explain the process of using ARIMA model to forecast a single time series, and analyze the model performance. Please take a look at this notebook for more information.\n",
    "\n",
    "In this notebook, we will train an ARIMA model on multiple splits (round) of the train/test data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global Settings and Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "System version: 3.6.10 |Anaconda, Inc.| (default, Mar 23 2020, 23:13:11) \n",
      "[GCC 7.3.0]\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import math\n",
    "import warnings\n",
    "import itertools\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scrapbook as sb\n",
    "from datetime import datetime\n",
    "\n",
    "from pmdarima.arima import auto_arima\n",
    "\n",
    "from fclib.common.utils import git_repo_path, module_exists\n",
    "from fclib.common.plot import plot_predictions_with_history\n",
    "from fclib.evaluation.evaluation_utils import MAPE\n",
    "from fclib.dataset.ojdata import download_ojdata, split_train_test, complete_and_fill_df\n",
    "\n",
    "pd.options.display.float_format = \"{:,.2f}\".format\n",
    "np.set_printoptions(precision=2)\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "print(\"System version: {}\".format(sys.version))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters\n",
    "\n",
    "Next, we define global settings related to the model. We will use historical weekly sales data only, without any covariate features to train the ARIMA model. The model parameter ranges are provided in params. These are later used by the `auto_arima()` function to search the space for the optimal set of parameters. To increase the space of models to search over, increase the `max_p` and `max_q` parameters.\n",
    "\n",
    "> NOTE: Our data does not show a strong seasonal component (as demonstrated in data exploration example notebook), so we will not be searching over the seasonal ARIMA models. To learn more about the seasonal ARIMA models, please take a look at the quick start ARIMA notebook, referenced above in the introduction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "# Use False if you've already downloaded and split the data\n",
    "DOWNLOAD_SPLIT_DATA = True\n",
    "\n",
    "# Data directory\n",
    "DATA_DIR = os.path.join(git_repo_path(), \"ojdata\")\n",
    "\n",
    "# Forecasting settings\n",
    "N_SPLITS = 5\n",
    "HORIZON = 2\n",
    "GAP = 2\n",
    "FIRST_WEEK = 40\n",
    "LAST_WEEK = 156\n",
    "\n",
    "# Parameters of ARIMA model\n",
    "params = {\n",
    "    \"seasonal\": False,\n",
    "    \"start_p\": 0,\n",
    "    \"start_q\": 0,\n",
    "    \"max_p\": 5,\n",
    "    \"max_q\": 5,\n",
    "}\n",
    "\n",
    "\n",
    "# Run notebook on a subset of stores (to reduce the run time)\n",
    "STORE_SUBSET = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Preparation\n",
    "\n",
    "We need to download the Orange Juice data and split it into training and test sets. By default, the following cell will download and spit the data. If you've already done so, you may skip this part by switching `DOWNLOAD_SPLIT_DATA` to `False`.\n",
    "\n",
    "We store the training data and test data using dataframes. The training data includes `train_df` and `aux_df` with `train_df` containing the historical sales up to week 135 (the time we make forecasts) and `aux_df` containing price/promotion information up until week 138. Here we assume that future price and promotion information up to a certain number of weeks ahead is predetermined and known. In our example, we will be using historical sales only, and will not be using the `aux_df` data. The test data is stored in `test_df` which contains the sales of each product in week 137 and 138. Assuming the current week is week 135, our goal is to forecast the sales in week 137 and 138 using the training data. There is a one-week gap between the current week and the first target week of forecasting as we want to leave time for planning inventory in practice.\n",
    "\n",
    "The setting of the forecast problem are defined in `fclib.dataset.ojdata.split_train_test` function. We can change this setting (e.g., modify the horizon of the forecast or the range of the historical data) by passing different parameters to this functions. Below, we split the data into `n_splits=N_SPLITS` splits, using the forecasting settings listed above in the *Parameters* section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data already exists at the specified location.\n",
      "Finished data downloading and splitting.\n"
     ]
    }
   ],
   "source": [
    "if DOWNLOAD_SPLIT_DATA:\n",
    "    download_ojdata(DATA_DIR)\n",
    "    train_df_list, test_df_list, _ = split_train_test(\n",
    "        DATA_DIR,\n",
    "        n_splits=N_SPLITS,\n",
    "        horizon=HORIZON,\n",
    "        gap=GAP,\n",
    "        first_week=FIRST_WEEK,\n",
    "        last_week=LAST_WEEK,\n",
    "        write_csv=True,\n",
    "    )\n",
    "\n",
    "    print(\"Finished data downloading and splitting.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create training data and test data for multi-round forecasting, we pass a number greater than `1` to `n_splits` parameter in `split_train_test()` function. Note that the forecasting periods we generate in each test round are **non-overlapping**. This allows us to evaluate the forecasting model on multiple rounds of data, and get a more robust estimate of our model's performance.\n",
    "\n",
    "For visual demonstration, this is what the time series splits would look like for `N_SPLITS = 5`, and using other settings as above:\n",
    "\n",
    "![Multi split](../../../../assets/time_series_split_multiround.jpg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Process training data\n",
    "Our time series data is not complete, since we have missing sales for some stores/products and weeks. We will fill in those missing values by propagating the last valid observation forward to next available value. We will define functions for data frame processing, then use these functions within a loop that loops over each forecasting rounds.\n",
    "\n",
    "Note that our time series are grouped by `store` and `brand`, while `week` represents a time step, and `logmove` represents the value to predict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_training_df(train_df):\n",
    "    \"\"\"Process training data frame.\"\"\"\n",
    "    train_df = train_df[[\"store\", \"brand\", \"week\", \"logmove\"]]\n",
    "    store_list = train_df[\"store\"].unique()\n",
    "    brand_list = train_df[\"brand\"].unique()\n",
    "    train_week_list = range(FIRST_WEEK, max(train_df.week))\n",
    "\n",
    "    train_filled = complete_and_fill_df(train_df, stores=store_list, brands=brand_list, weeks=train_week_list)\n",
    "\n",
    "    return train_filled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Process test data\n",
    "\n",
    "Let's now process the test data. Note that, in addition to filling out missing values, we also convert unit sales from logarithmic scale to the counts. We will do model training on the log scale, due to improved performance, however, we will transfrom the test data back into the unit scale (counts) by applying `math.exp()`, so that we can evaluate the performance on the unit scale.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "def process_test_df(test_df):\n",
    "    \"\"\"Process test data frame.\"\"\"\n",
    "    test_df[\"actuals\"] = test_df.logmove.apply(lambda x: round(math.exp(x)))\n",
    "    test_df = test_df[[\"store\", \"brand\", \"week\", \"actuals\"]]\n",
    "    store_list = test_df[\"store\"].unique()\n",
    "    brand_list = test_df[\"brand\"].unique()\n",
    "\n",
    "    test_week_list = range(min(test_df.week), max(test_df.week) + 1)\n",
    "    test_filled = complete_and_fill_df(test_df, stores=store_list, brands=brand_list, weeks=test_week_list)\n",
    "\n",
    "    return test_filled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model training\n",
    "\n",
    "Now let's run model training across all the stores and brands, and across all rounds. We will re-run the same code to automatically search for the best parameters, simply wrapped in a for loop iterating over stores and brands.\n",
    "\n",
    "We will use [Ray](https://ray.readthedocs.io/en/latest/#) to distribute the computation to the cores available on your machine if Ray is installed. Otherwise, we will train the models for different stores, brands, and rounds sequentially. By the time we develop this example, Ray only supports Linux and MacOS. Thus, sequential training will be used on Windows. In the cells below, we first define a function that trains an ARIMA model for a specific store-brand-round. Then, we use the following to leverage Ray:\n",
    "- `ray.init()` will start all the relevant Ray processes\n",
    "- we define a function to run an ARIMA model on a single brand and single store. To turn this function into a function that can be executed remotely, we declare the function with the ` @ray.remote` decorator.\n",
    "- `ray.get()` collects the results, and `ray.shutdown()` will stop Ray.\n",
    "\n",
    "It will take around 4.5 minutes to run the below cell for 5 rounds on a machine with 4 cores and about 2.7 minutes on a machine with 6 cores. To speed up the execution, we model only a subset of twenty stores in each round. To change this behavior, and run ARIMA modeling over *all stores and brands*, switch the boolean indicator `STORE_SUBSET` to `False` under the *Parameters* section on top."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_store_brand(train, test, store, brand, split):\n",
    "    train_ts = train.loc[(train.store == store) & (train.brand == brand)]\n",
    "    train_ts = np.array(train_ts[\"logmove\"])\n",
    "\n",
    "    model = auto_arima(\n",
    "        train_ts,\n",
    "        seasonal=params[\"seasonal\"],\n",
    "        start_p=params[\"start_p\"],\n",
    "        start_q=params[\"start_q\"],\n",
    "        max_p=params[\"max_p\"],\n",
    "        max_q=params[\"max_q\"],\n",
    "        stepwise=True,\n",
    "        error_action=\"ignore\",\n",
    "    )\n",
    "\n",
    "    model.fit(train_ts)\n",
    "    preds = model.predict(n_periods=GAP + HORIZON - 1)\n",
    "    predictions = np.round(np.exp(preds[-HORIZON:]))\n",
    "\n",
    "    test_week_list = range(min(test.week), max(test.week) + 1)\n",
    "\n",
    "    pred_df = pd.DataFrame(\n",
    "        {\"predictions\": predictions, \"store\": store, \"brand\": brand, \"week\": test_week_list, \"round\": split + 1,}\n",
    "    )\n",
    "    test_ts = test.loc[(test.store == store) & (test.brand == brand)]\n",
    "\n",
    "    return pd.merge(pred_df, test_ts, on=[\"store\", \"brand\", \"week\"], how=\"left\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ray is available. Parallel training will be used. \n",
      "\n",
      "Initializing Ray...\n",
      "Address information about the processes started by Ray:\n",
      "{'node_ip_address': '172.18.9.4', 'redis_address': '172.18.9.4:45060', 'object_store_address': '/tmp/ray/session_2020-03-31_20-37-43_347276_81682/sockets/plasma_store', 'raylet_socket_name': '/tmp/ray/session_2020-03-31_20-37-43_347276_81682/sockets/raylet', 'webui_url': 'localhost:8265', 'session_dir': '/tmp/ray/session_2020-03-31_20-37-43_347276_81682'} \n",
      "\n",
      "20:37:44.015663 --- Round 1 ---\n",
      "Training ARIMA model ...\n",
      "20:38:11.713901 --- Round 2 ---\n",
      "Training ARIMA model ...\n",
      "20:38:39.725381 --- Round 3 ---\n",
      "Training ARIMA model ...\n",
      "20:39:09.059834 --- Round 4 ---\n",
      "Training ARIMA model ...\n",
      "20:39:52.311496 --- Round 5 ---\n",
      "Training ARIMA model ...\n",
      "CPU times: user 26.6 s, sys: 1.83 s, total: 28.4 s\n",
      "Wall time: 2min 40s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "if module_exists(\"ray\"):\n",
    "    print(\"Ray is available. Parallel training will be used. \\n\")\n",
    "    \n",
    "    import ray\n",
    "    import logging\n",
    "    \n",
    "    # Initialize Ray\n",
    "    print(\"Initializing Ray...\")\n",
    "    address_info = ray.init(log_to_driver=False, logging_level=logging.ERROR)\n",
    "    print(\"Address information about the processes started by Ray:\")\n",
    "    print(address_info, \"\\n\")\n",
    "\n",
    "    @ray.remote\n",
    "    def ray_train_store_brand(train, test, store, brand, split):\n",
    "        return train_store_brand(train, test, store, brand, split)\n",
    "\n",
    "    # Create an empty df to store predictions\n",
    "    result_df = pd.DataFrame(None, columns=[\"predictions\", \"store\", \"brand\", \"week\", \"round\", \"actuals\"])\n",
    "\n",
    "    for r in range(N_SPLITS):\n",
    "        print(f\"{datetime.now().time()} --- Round \" + str(r + 1) + \" ---\")\n",
    "\n",
    "        # Process training data set\n",
    "        train_df = train_df_list[r].reset_index()\n",
    "        train_filled = process_training_df(train_df)\n",
    "\n",
    "        # Process test data set\n",
    "        test_df = test_df_list[r].reset_index()\n",
    "        test_filled = process_test_df(test_df)\n",
    "\n",
    "        store_list = train_filled[\"store\"].unique()\n",
    "        brand_list = train_filled[\"brand\"].unique()\n",
    "\n",
    "        if STORE_SUBSET:\n",
    "            store_list = store_list[0:20]\n",
    "\n",
    "        # persist input data into Ray shared memory\n",
    "        train_filled_id = ray.put(train_filled)\n",
    "        test_filled_id = ray.put(test_filled)\n",
    "\n",
    "        # train for each store/brand\n",
    "        print(\"Training ARIMA model ...\")\n",
    "        results = [\n",
    "            ray_train_store_brand.remote(train_filled_id, test_filled_id, store, brand, r)\n",
    "            for store, brand in itertools.product(store_list, brand_list)\n",
    "        ]\n",
    "\n",
    "        result_round = pd.concat(ray.get(results), ignore_index=True)\n",
    "\n",
    "        result_df = result_df.append(result_round, ignore_index=True)\n",
    "\n",
    "    # Stop Ray\n",
    "    ray.shutdown()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "If Ray is not installed, we will train all the models sequentially as follows. The training time could be several times longer compared with training the models in parallel with Ray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 16.2 ms, sys: 13 µs, total: 16.2 ms\n",
      "Wall time: 15.4 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "if not module_exists(\"ray\"):\n",
    "    print(\"Ray is not available. Sequential training will be used. \\n\")\n",
    "    \n",
    "    from tqdm import tqdm\n",
    "    \n",
    "    # CHANGE to False to model across all stores\n",
    "    subset_stores = True\n",
    "\n",
    "    # Create an empty df to store predictions\n",
    "    result_df = pd.DataFrame(None, columns=[\"predictions\", \"store\", \"brand\", \"week\", \"actuals\", \"round\"])\n",
    "\n",
    "    for r in tqdm(range(N_SPLITS)):\n",
    "        print(\"-------- Round \" + str(r + 1) + \" --------\")\n",
    "\n",
    "        # Process training data set\n",
    "        train_df = train_df_list[r].reset_index()\n",
    "        train_filled = process_training_df(train_df)\n",
    "\n",
    "        # Process test data set\n",
    "        test_df = test_df_list[r].reset_index()\n",
    "        test_filled = process_test_df(test_df)\n",
    "\n",
    "        print(\"Training ARIMA model ...\")\n",
    "        store_list = train_filled[\"store\"].unique()\n",
    "        brand_list = train_filled[\"brand\"].unique()\n",
    "\n",
    "        if subset_stores:\n",
    "            store_list = store_list[0:10]\n",
    "\n",
    "        for store, brand in itertools.product(store_list, brand_list):\n",
    "            combined_df = train_store_brand(train_filled, test_filled, store, brand, r)\n",
    "            result_df = result_df.append(combined_df, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Note that since `auto_arima` model makes consecutive forecasts from the last time point, we want to forecast the next `n_periods = GAP + HORIZON - 1` points, so that we can account for the GAP, as described in the data setup.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model evaluation\n",
    "To evaluate the model, we will use *mean absolute percentage error* or [MAPE](https://en.wikipedia.org/wiki/Mean_absolute_percentage_error)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAPE values for each forecasting round:\n",
      "round\n",
      "1   59.98\n",
      "2   77.02\n",
      "3   62.05\n",
      "4   73.62\n",
      "5   68.83\n",
      "dtype: float64\n"
     ]
    },
    {
     "data": {
      "application/scrapbook.scrap.json+json": {
       "data": 68.29505356232335,
       "encoder": "json",
       "name": "MAPE",
       "version": 1
      }
     },
     "metadata": {
      "scrapbook": {
       "data": true,
       "display": false,
       "name": "MAPE"
      }
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overall MAPE is 68.30 %\n"
     ]
    }
   ],
   "source": [
    "mape_r = result_df.groupby(\"round\").apply(lambda x: MAPE(x.predictions, x.actuals) * 100)\n",
    "\n",
    "print(\"MAPE values for each forecasting round:\")\n",
    "print(mape_r)\n",
    "\n",
    "metric_value = MAPE(result_df.predictions, result_df.actuals) * 100\n",
    "sb.glue(\"MAPE\", metric_value)\n",
    "\n",
    "print(f\"Overall MAPE is {metric_value:.2f} %\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The resulting MAPE value is relatively high. As `auto_arima` searches a restricted space of the models, defined by the range of `p` and `q` parameters, we often might not find an optimal model for each time series. In addition, when building a model for a large number of time series, it is often difficult to examine each model individually, which would usually help us improve an ARIMA model. Please refer to the [quick start ARIMA notebook](../00_quick_start/auto_arima_forecasting.ipynb) for a more comprehensive evaluation of a single ARIMA model.\n",
    "\n",
    "Now let's plot a few examples of forecasted results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAARRCAYAAADQPHLpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeXxdVb3//9cnTZvTIWla2qQpBVq1AiKUoWARRLAKRUW4fkHEARClilzH63zlFsXx6g8Vr8K3X0FAGRQEwSuCDBaU0SKojFKgQEmadExS2pM2yef3x1o7PTk9GU5ykpPkvJ+PRx4n2XvttdfeOcPen/NZa5m7IyIiIiIiIiIykpUVuwEiIiIiIiIiIn1RAENERERERERERjwFMERERERERERkxFMAQ0RERERERERGPAUwRERERERERGTEUwBDREREREREREY8BTBERIaImc01Mzezy7OWXx6Xzx2i/R4d6z9/KOovBWZ2fjyHRxdh31VmdpGZrTaz9tiOA4e7HYVkZrPM7AozW2NmHfGYqovdrlLR03vRMLfBzWxFsfY/muhciYj0rLzYDRARGQwz86xFncAm4B/Ape5+1fC3amjFwMfzwBXufmZRG1Ni4vPtbnc/egh389/AR4H/BX4BdABrh3B/w+Fy4FjgGmAV4EC6mA2SwjKz1QDuPre4LRERkbFMAQwRGSu+Fh/HA3sDJwHHmNkh7v7Z4jUrpy8D3wFeHqL6HwL2BdYPUf0ytN4J/MvdTyh2QwrBzCYAbwPucPf3F7s9UjT7AluL3YhRQudKRKQHCmCIyJjg7udn/m1mi4HbgU+b2UXuvroY7crF3RuAhiGsfyvw1FDVL0NuNnBPsRtRQLMIXVbri90QKR5313tSP+lciYj0TGNgiMiY5O53Em7iDTgUuvcDN7PXmtmvzKzJzDozxzows+lm9m0ze9LMtplZs5ndaWbH5tqXmVWa2YWxf3/azJ4ys8/Sw3tsb2NgmNlhsV0vm1mbmTWY2R/N7D1x/fmE7iMAZ8R6kp8zY5kex8Aws/lmdmWsf7uZ1ce/5+co2zUOhJmdbGYPmdlWM9toZtea2e49nf8cdZ2ZtNHMlpjZinhePavcPvH8vBSPv9HMrjazvXPUWWtm3zezp83sFTPbHH+/3MxelWvfPbStz/7mSR3xzzdnnffzM8q9Kz5XGmL7683sbjP7eD/O0Yq4D8vax4qMMmVm9jEz+6uZbYnH/VczO8fMdnm+JdtbGIPiZ/H/3tHTucjYboKZ/buZ3WJmL8Rj2Whmd5jZ8X0dS0Y9q4EX4p+Zz9fLs8qdZmZ/MrNN8TX0pJl91cwqssrVm9maHPt5IdZ7Xtbyt8flX+9HW83MzjCz+8xsXWzHS2Z2m5mdmlX2GDNbbmZPmFmLhfeJx8xsmZmlctSd+Vo6zcwejq+legvvHRWx3Fvi/6slnotfmNluuc5r/JlqZv8T/6/p2J5Pmpn1dbwZdU0ysy+b2aPx+bTFzO43s9P6uf3R8Xm7F7BX1mvj8oxyu7zOCn1eYtk58Zw8F5+3G8zsZjM7tL/nJNbT79ey5fGZYf14L8x1ruLycjP7uJk9EM/FVjN7xMJrNdfrf8DvRyIiI5UyMERkLEsu4rPHyXg18CDwL+AqYCLQAmBmewErgLnAn4FbgcmEtP5bzeyj7v7/unYQLrDvJARJ/h7rqwbOA96cV2PNzgYuJox5cDPwDFADLAQ+Dvw6tq0a+FTc328zqni0j/oPBe4AKmP9TwD7AO8HTjSzxe6+MsemHwfeFbe5G3gDcCqwwMwOdPe2PA7zZGAJ8AfgEsJ5Ttq3BLiB0A3od4SxEuYA7wbeYWbHuPvfYtlJwL2E/+XtsbwRbqJOBK4HnsujXX15lNBNaRnhhvzyjHUrYpuWAv+XMF7F7whdeGqAA4APAT/tYx+Xx7qy97E6o8wvgPcBLwE/Izy3/y3WfSThf5ltOvAAsIVwfjuBxj7aMh34EXAf4fyuA+qAE4BbzOxsd/9ZH3UA/JDwP85+vnY9V83sUuAsYE1s32ZgEXABsNjM3ubu7bH4XcD7zWyf5FtqM3sNsGdcvzhul3hLfLyzH239JqF71/OE11pzPOZDgVOAX2WU/SLhtXMf8HsgBRwBnA8cbWZvdfeOHPv4BHB8PA8rCOOCfAaYbmY3AdfG+pYDbwQ+AMyI22SbQHg9V8ftJgD/h/B/2xs4t68DtjCQ6l3AQcDfgMsIgdfjgKvNbD93/2of1awmvDY+Hf/+Yca6Xt+TMhTkvJjZwcAfCc/f2wjPpxmELoV/MbN/c/db+mpMPq/lfD8zMvT4XthDm5L3xeOAp4GrCePIHAP8mPC+/MGBHIOIyKji7vrRj370M2p/CDdwnmP5Wwk3ap3AXnHZ3KQ88K0e6lsRt3lv1vJqwsX4NqA2Y/lXYn2/Acoyls8DNsZ1l2fVdXlcPjdj2euAHXGb/XK0a07G73Nz1Zux/ui4/vyMZQY8GZe/P6v8qXH5U1nHcH5c3gLsn7XN1XHde/r5fzozlu8EluRYP40w+Op64HVZ6/Yj3Hz/LWPZCbG+H+SoawJQmWPfZ/byHFqRtSw59qP7Kpux7mGgDajJsW5Gns/pXfYBnBbX/Q2YkrF8MrAyrntfrtcHcCVQnkcbKjKfcxnLpwKPxefpxH7W1ePzNeN/c0N2fRn/g09lLDsrLjs3Y9lH47I/xvM/KWPdI4SxBCb0o50bCEGUSTnWzcj6+1WA5Sh3QWzLqT0cSzOwb9Z5fpwQtNwAvDljXRkheOTAgVn1rY7L/wJUZCyfDjwb1x3V1/+Ane9FX8haniLciHdm77uX87caWJ3P87qQ54Xwpdwqwk39m7P2M5sw5lBD5vnqpa39fi2T/2fGmfTyXtiPc/VjYFzG8nHApXHdiQM5Bv3oRz/6GU0/6kIiImNCTEU+38y+aWbXEy6+Dfihu7+QVbyRnYN+ZtaxgJA18Rt3vzZznbtvJnwzniJ8y5n4EOFC9Avu3plR/nngojwO4RzCBfgF7v549kp33yVtPk9vJHxjfL9nzczi7r8i3AjtTfgWP9tF7v7PrGXJN4qH5dmOm9z91hzLTydc8C9z9yey2vd43N9BZva6rO22ZVfk7tvdvTXPdhVKOyEQ1Y27F2JA1bPi45fcfUtG3a8QMgIAPpJju+3A53xnFkOf3L0t13PO3ZsJ39JPI3bNGqRPEc7ZWe6e/b+8gHDzmplVkmRSLM5YthhoIrzeJhCfw7GLwQLgL+6+vZ/t2UG4ae4m+//n7s+5e3ZmF+zMPjiuh/ovcvcnM+ppI2R2lAG/d/e7M9Z1Ar+Mfy7oob4ve0YGlLtvZGcGyod62AboOj8fAFa6+39nrnP3NOE5ZYSMn6FWiPPyDkJG1o8zy8dt6gmz+8yi+3OnN32+lgf4mZHo6b1wF7F7yL8Tsik+4xnZPfH3/yAGp/M9BhGR0UZdSERkrFgWH52Qgv5nwjSqv8xR9u+eu9vD4fFxquUYPwKYGR/3hTD2BfAa4CV3fzZH+RUZ7erLovj4h36Wz9fB8fGuHtbfRbjxO4hdB5DM1a3kpfg4Lc92PNTD8uTcL+jh3L82Pu5L6PpyN+Eb1S/FtPFbCF1KHvXcqfvD4Srg/wMeN7NfxTbe6+7rClT/wYRg2Yoc6+4m3HgflGPdandvyndnZrYf8HngKEJXiuyxHfo9BkoP9U8i3ICuJwy2m6tYG/H1BuDuL5jZc4QZhsqIWTKErhR3E27YFhOyMY4h3ID39JzPdhWhK8PjZnZdrO/+GLTJbvtkQvDl3wjPzUp2dlmDns9NrtdSMrjpwznWJTMVzcmxrp3QhSXbiviY67mQ6VDCt/c5x8shdOWCjPM/hApxXpL3kL16OJ5knJ99Ce8Xvenvazmvz4wsPb0X5vJaYDdCt8Kv9vBa2Za1n6F+PxIRKQoFMERkTHD3fg9aR/gWK5dkULi3xZ+eTImPU+NjT+MJ9LSfXKrj41BNrZq0tafZT5Ll1TnWbc6xLPk2f1ye7ejr3J/dx/ZTANy9xcwWETJp3sXOb7zXm9lPgW+4+y7fPA4ld7/QzNYTxgz5JGFMADezu4HPe+7xRfIxFdiYK5vA3dvjvmtybJfP8xCAeG7vIlwn3EkY/6SF2KWAMM5IRY8V9M80wk3/TPof6CO252xCQGdH3P5Od281s7+y8xv2xRnl++MzhO4XZwFfij/tZnYL8B/uvgq6xiK4i5B99BghU2AdO7/pXkbP52aXYAg7X0u9rRufY936HoJ1yf97ao51mZLX3KH0nk0zpZd1hVKI85Iczyl97KvP48njtZzvZ0amfF6XyX7m0/trpWs/w/B+JCJSFApgiEgpypX6DTsvlD/l7v3p/pGUr+1h/aw82pQECXZnaKZATdraU5vqssoNlb7O/QJ3/0e/KgpdHD5s4evI1xEGbDwX+C9C6nkyI0XStWeXz7w4iGHBuPuVwJWx3jcSvqE/C7jNzPYdSCZEhmbCoIbjs4MzZlZOGKywJVezBrCvrxIGtz3G3Vdk7evLhADGYCX/80fc/eBeS3Z3FyGA8VZC95hkWfL4ZTObTghgNBPGDOlTDAb8CPiRmdUQMpLeS7gh3i8OaNlGOPbDgCvc/czMOsysjvyCMYMxw8zG5QhiJK/xvl7LyfofuPtnC9u0okiO50R3v3mwlfXztZzvZ0a3XeRRNtnPje7+7n7vYGjfj0REikJjYIiI7PRAfHxTfwrHcRZWAbub2atzFDl6APvuzxSVyQ1LPtkPj8THo3tYnyzv183eEMjr3Gfy4HF3/zE7vwU9KaPIpvi4R47NF+a5u076cd7dfbO73+LuZxMGSpzOAI4tyyOEz+2jcqw7KrarUP+/1xCyPVbkWPfmQuwgjuPxOCE4MD2PTe8i3PwtJgStnotjzkDItigjzMYwnzAQYt5dity9yd1vcPf3xP29Gnh9XP2a+PibHJsW5Nz0UznhpjTb0fHxkRzrMj1EeD4P9nmZ6CD/jKxCGvB7SG/6eC0PyT5zeIo4O0/MAMrLEL0fiYgUhQIYIiJRTKn9M/BuMzsrVxkz2z9+O5v4OeG99LuxT35Sbh4hbbe/LiakRZ+XY6BKzCyzr/cmwg3cntnlenEvYeq9I83s5Ky6TybcAP+LMJhnMfyccIG+zMx2GRjUzMrM7OiMv19vZnNz1JNkw2zNWLaScKP2vjjuQlLHdMLAfvnYQO5ACGa2JGZCZEueL1tzrMvHZfHx21nHMQn4Tvzz0kHuI7GakO1xQOZCM/swPQ9QORAXEgbevCxXNoyZTYtjnHSJ3xo/Tpi29Ci6dxG5jzALxVfi3/0a/8LMKsxssWUNLhBvFpPgSvL/Wx0fj84q+yrgu/3ZXwF9O07lnLRhOiF7BsJrqkfxPF4FLDSz83I9d83s1fG9rD82ADPNbGI/yxfaTYQuQOea2dtzFTCzwzNfOz3p72t5gJ8ZeYsD8P6YkCl3Ua5zbGZ1mZ8dw/B+JCJSFOpCIiLS3fsINz2XmtkngQcJN9ZzgAMI38IeTpj1AMIgaScRRpn/m5ndRuh7fiphMMx39Wen7v6EmX0cuAR4xMxuIgzYthshS6CVMCgh7r7FzB4E3mRmVxECDx3AzT11v3B3N7MzCNMP/irW/xRh5pGTYv2nZ86kMpzcfUMMpNwIPGBmdxJuUjsJgZrDCeciGUjyrcCFZnYf4TiaCP+jE+M238uouyGepw8Cj5rZ74Eq4O2E/1Ffgx1muhN4r5n9jjC4YDtwj7vfA1wLpM3sL4SbXCN8y3loLHtHPuckm7tfbWYnAu8hDMz3W0Ig6yTCtL2/zp5hZhB+SAhU/MXMfk1IYV9I6FZxPXByL9v2m7tfZmaHEPrpPxtfPy8SggbzCAGKnwMfy9r0TnZmRHQFMNy9zczuJf/xLyYS/j+r42vrBcJz7W2EgRFvzpgl43eEzKvPmtn+hEyHPYF3Ar8nv8DiYDQQxtp4zMxuJowHcTLhJven8TnZl38nZKp8HfhgfO42EqYd3Zfw3D0NeL7HGna6M5a/1czuIQzA+nd3/11eRzVA7r7DzN4N3Ab8Pr43PEq4Ud8jtu1VhPPT1817Pq/lfD8zBuoCwqC3HwNOMLO7CGMm1RD+h0cA/0kY5DjfYxARGTUUwBARyeDua+IN1ScIQYn3E9Ki1xIuDH8M/DOjfJuZvRU4nxC0+BThYvEbhJvxfgUwYl3/z8weAz5H+Hb3JMIMDf8AfpZV/IPAD4AlhBsMA9bEsj3V/6CZHUr4hvatwAmx/msI07c+3d+2DgV3vzN+4/85ws3zmwhjHNQTbhAyU/ZvI9xkH0UIWlQRbuhuBy509+zZGc4m3JidRhgn40XCtJvfIwQE+utT7Oy+8HZC9s3XCIGQL8V2HxzXpQk3wl8ELi7QoKKnEWYTOAv4aFz2JCGQdnEB6gfA3W81sxMIz5VTCQGyhwhBtFdRoABG3Ne5ZvYHwo3ZWwkDyW4k/I++x84pMzPdyc7/xZ9yrFsMNHqOKYl7kExFewyhW0YS1HuWMMVxkv2Cu79iZm8hZL0cTXiePke4wbyQcL6Gw3bC+foWYayOGbEd3yG8T/UpDob7ZmAp4Ub8/xACN42EAOpnCK+p/vgG4X93AuFmehxwBSHgMyzc/R8Wpjb9LCGglExz3UAINC0jvOf1pd+v5Xw/MwZxbDvM7CTC1LdnxuObQhhA9nnCmD+ZAczheD8SERl25jmnMRcRERGRkcjMVgO4+9zitkRERGR4aQwMERERERERERnxFMAQERERERERkRFPAQwRERERERERGfE0BoaIiIiIiIiIjHjKwBARERERERGREU8BDBEREREREREZ8RTAEBEREREREZERTwEMERERERERERnxFMAQERERERERkRFPAQwRERERERERGfEUwBARERERERGREU8BDBEREREREREZ8RTAEBEREREREZERTwEMERERERERERnxFMAQERERERERkRFPAQwRERERERERGfEUwBARERERERGREU8BDBEZFczsaDNbU6r7FxERkcEzs9Vm9tZS3b/IaKcAhkgJMbPzzeyXw7i/uWbmZrYl4+e8jPXfN7NnzKzVzJ4ys9OHq22FZmZvNLOH4rH8w8yOLHabREREhttIu9YYjcxsQrwu0hcnIlnKi90AERk9zKzc3dsHsGl1D9u9ApwA/As4FLjVzFa5+32DaSeAmY1z947B1tPPfU0HbgbOAW4ATgN+Z2avcvdNw9EGERGRsWAIrjWK0ZbB+jzQBEwpwr5FRjRlYIiMQWb2RTN7OWYDPG1mi81sCfAV4NT47cTfY9nZZnazmW00s1VmdnZGPeeb2fVm9kszawHONLMyM/uSmT1rZhvM7NfxBj5v7r7M3Z9y9053fxD4M3B4H8f2FTNbH1Mw35+x/HIzu9jMbjGzV4BjzOwdZvaImbWY2Utmdn5G+eQbmzPM7MVY539mrJ8Y69xkZk8QAiw9eSPQ6O7XuXuHu/8SWAe8eyDnRUREZKQbLdcaPTjUzJ6In/E/N7NUbMvRZrYmHtta4OdmNs3M/tfM1sXy/2tmczLav8LMLjCze+O5+KOZzchY/0EzeyEex3/maEs3ZjYP+ADw7QIer8iYoQCGyBhjZnsD/w4c6u6VwHHAane/FfgW8Ct3n+LuC+Im1wBrgNnAycC3zGxxRpUnAtcD1cBVwCeBk4A3x202AT/po1kvxAuCn2d+qGe1eyIhSPB4L/XMAmYAuwNnAMvj8SbeB3wTqAT+QsjwOD22/R3AOWZ2UladRwJ7A4uB/zKzfePyZcCr489xcX89sfiTvez1vWwjIiIyKo3Wa40M749tfjXwWuCrGetmAdOBvYClhPuln8e/9wS2Af+TVd/7gA8BNcAE4HMAZvY64GLgg/E4dgPm0LsfE4JA2/ooJ1KSFMAQGXs6gArgdWY23t1Xu/uzuQqa2R6EG/gvunva3R8Ffkb4oE3c7+6/jVkS24CPAv/p7mvcvQ04HzjZzHJ1SVtPCErsBRxCCCxc1UO7LwH+DtzWx/Gd5+5t7n438HvgPRnrbnL3e2Nb0+6+wt3/Gf/+B+EC6s1Z9X3N3be5+9/j/pOLrfcA33T3je7+EnBRL226D5htZqeZ2XgzO4NwUTSpj2MREREZjUbrtUbif9z9JXffSPji47SMdZ3Asnitsc3dN7j7b9x9q7u3xvLZ1xI/d/d/xbb/GjgwLj8Z+F93vycex3mx/pzM7N+Acne/sY/2i5QsBTBExhh3XwV8mvBh32Rm15rZ7B6KzwY2xg/kxAuEDIfES1nb7AXcaGabzWwz8CThQqY2R1u2uPtKd29390bCtzXHmllVZjkz+x4hW+E97u69HN4md38lq62Zx9atrWb2BjP7U0z7bAY+RsjgyLQ24/et7OxvOjurvhd6apS7byB8e/RZoBFYAtxB+LZJRERkTBmN1xpZsj/fM9u+zt3TyR9mNsnM/m/sBtIC3ANUm9m4jG36dS0Rr2E25GqQmU0G/hv4RC/tFil5CmCIjEHufrW7H0m4AHDgu8mqrKL1wHQzq8xYtifwcmZ1Wdu8BBzv7tUZPyl3f5m+JXV1dbcws68BxwPHuntLH9tPix/wmW2t76WtVxMG19zD3acSsjyyu3r0pAHYI2tfPXL3u939UHefTvhWaW/goX7uS0REZFQZTdcaOWR/vvd2LfEfhM/0N7h7FXBUP+pPdLuWMLNJhG4kucwH5gJ/juNv3ADUmdlaM5vbj32JlAQFMETGGDPb28zeYmYVQJrQhzKZjaMRmGtmZQCxa8R9wLfNLGVmBwAfpvfUy0uAb5rZXnF/M83sxB7a8obYnjIz243QDWOFuzfH9V8m9Bt9W8xi6I+vWZhe7E3AO4HreilbSfjWJ21mh8V99devgS/Hwbvm0Mc3ImZ2UOw+UgV8H1jj7n11hxERERl1RtO1Rg/ONbM5cWDQrwC/6qVsZTy+zbH8sl7KZrseeKeZHWlmE4Cv0/P912OEYMeB8ecjhHN5ILtmqIiULAUwRMaeCuA7hD6hawkDSn0lrktu9jeY2d/i76cRIv71wI2Efp+391L/jwhZDX80s1bgAeANPZR9FXAr0Er4YG6jez/TbxG++XjGds7d/pVdq+myljCQVz3hwudj7v5UL+U/Dnw9tvO/CEGJ/voaIa30eeCPwC/6KP8Fwjl/CagD/i2PfYmIiIwmo+laI5erCZ/tz8Wfb/RS9ofARMKxPhD31S/u/jhwbtxfA+EaJmf30tgFZm3yA2wEOuPfwzItvMhoYL13NxcRERERERERKT5lYIiIiIiIiIjIiKcAhoiIiIiIiIiMeApgiIiIiIiIiMiIpwCGiIiIiIiIiIx45cVuwHCbMWOGz507t9jNEBERGTMefvjh9e4+s9jtKAZdV4iIiBReT9cWJRfAmDt3LitXrix2M0RERMYMM3uh2G0oFl1XiIiIFF5P1xbqQiIiIiIiIiIiI54CGCIiIiIiIiIy4imAISIiIiIiIiIjXsmNgSEiIqVlx44drFmzhnQ6XeymjHqpVIo5c+Ywfvz4YjdFRESkaHRtUTj5XlsogCEiImPamjVrqKysZO7cuZhZsZszark7GzZsYM2aNcybN6/YzRERESkaXVsUxkCuLdSFRERExrR0Os1uu+2mC4xBMjN22203fdskIiIlT9cWhTGQawsFMEREZMzTBUZh6DyKiIgE+kwsjHzPowIYIiIiIiIiIjLiKYAhIiIygqxYsYL77rtvUHVMmTKlQK0RERGR0W4sXVtoEE/ZxW8feZnv3fY09Zu3Mbt6Ip8/bm9OOmj3YjdLRGRYFPs9cMWKFUyZMoU3vvGNw7bP0cTMPgN8BHDgn8CHgDrgWmA68Dfgg+6+3cwqgCuBQ4ANwKnuvjrW82Xgw0AH8El3vy0uXwL8CBgH/MzdvzN8RyciUtqK/Rk8VIp9XGPp2kIZGNLNbx95mS/f8E9e3rwNB17evI0v3/BPfvvIy8VumojIkBvK98CTTjqJQw45hP3224/ly5cDcOutt3LwwQezYMECFi9ezOrVq7nkkkv4wQ9+wIEHHsif//xnzjzzTK6//vquepJvQLZs2cLixYs5+OCD2X///bnpppsG3caRzsx2Bz4JLHT31xOCDO8Fvgv8wN3nA5sIgQni4yZ3fw3wg1gOM3td3G4/YAnwUzMbZ2bjgJ8AxwOvA06LZUVEZIiN1fsQXVsUljIwpJvv3fY023Z0dFu2bUcH37vt6TER/RSR0va13z3OE/UtPa5/5MXNbO/o7LZs244OvnD9P7jmoRdzbvO62VUsO2G/Pvd92WWXMX36dLZt28ahhx7KiSeeyNlnn80999zDvHnz2LhxI9OnT+djH/sYU6ZM4XOf+xwAl156ac76UqkUN954I1VVVaxfv55Fixbxrne9qxQGFSsHJprZDmAS0AC8BXhfXH8FcD5wMXBi/B3geuB/LJygE4Fr3b0NeN7MVgGHxXKr3P05ADO7NpZ9YoiPSUSk5I3W+xBdWwwvBTCkm/rN2/JaLiIylmRfYPS1PB8XXXQRN954IwAvvfQSy5cv56ijjuqa93z69Ol51efufOUrX+Gee+6hrKyMl19+mcbGRmbNmjXoto5U7v6ymX0feBHYBvwReBjY7O7tsdgaILnS3R14KW7bbmbNwG5x+QMZVWdu81LW8jcMwaGIiEiWsXofomuLwlIAQ7qZXT2Rl3O8ScyunliE1oiIFFZf32Yc8Z27cr4H7l49kV999PAB73fFihXccccd3H///UyaNImjjz6aBQsW8PTTT/e5bXl5OZ2d4SLH3dm+fTsAV111FevWrePhhx9m/PjxzJ07N6951EcjM5tGyIiYB2wGriN098jmySY9rOtpea6utZ69wMyWAksB9txzzz7bLSIifRut9yG6thheGgNDuvn8cXszflz367qJ48fx+eP2LlKLRESGz+eP25uJ48d1W1aI98Dm5mamTZvGpEmTeOqpp3jggQdoa2vj7rvv5vnnnwdg48aNAFRWVtLa2tq17dy5c3n44YcBuOmmm9ixY0dXnTU1NYwfP54//elPvPDCC4Nq4yjxVuB5d1/n7juAG4A3AtVmlnwpMweoj7+vAfYAiOunAjjKhZUAACAASURBVBszl2dt09Pybtx9ubsvdPeFM2fOLNSxiYiUtKH6DC42XVsUlgIY0s1JB+3OcfvVdv29e/VEvv3u/Ud0vzMRkUI56aDd+fa792f36okYhXsPXLJkCe3t7RxwwAGcd955LFq0iJkzZ7J8+XLe/e53s2DBAk499VQATjjhBG688caugbbOPvts7r77bg477DAefPBBJk+eDMD73/9+Vq5cycKFC7nqqqvYZ599Bnv4o8GLwCIzmxTHslhMGJ/iT8DJscwZQDLq2M3xb+L6u9zd4/L3mlmFmc0D5gMPAX8F5pvZPDObQBjo8+ZhOC4RkZJ30kG7c/4JO8dNrqmsGBP3Ibq2KCwLn+OlY+HChb5y5cpiN2NEO++3j/GLB16gsqKcf37tuGI3R0RkUJ588kn23XffYjdjzMh1Ps3sYXdfOBz7N7OvAacC7cAjhClVd2fnNKqPAB9w9zYzSwG/AA4iZF68N2OAzv8Ezor1fNrd/xCXvx34IWGGk8vc/Zu9tUfXFSIihfP8+lc45vsrALjyrMM46rUjM8tN1xaFlc+1hcbAkF00NId+Tq1t7bSmd1CZGl/kFomIiATuvgxYlrX4OXbOIpJZNg2c0kM93wR2CU64+y3ALYNvqYiI5KuxJZ3zd5GEupDILta27BxkZm2z3jhERERERGToNbW25fxdJKEAhuyiYXOa+TVTAKhXAENERERERIZBU8y6mDCuTBkYkpMCGNJNekcHG17ZzsF7TgNgbfPonndZRERERERGh6bWNirKy5g7Y5ICGJKTAhjSTfJGceCe1ZhB/Wa9cYiIiIiIyNBrbElTU1VBbVWKxhZ1IZFdKYAh3SQDeO4xbRIzp1TQoAwMEREREREZBo0taWorU9RWpbq6k4hkUgBDukkCFrOmpqibmuoKaIiIyMgxZUocp6i+npNPPrnXsj/84Q/ZunVrXvWvWLGCd77znQNun4iIyEA0tbbFDIwKmlrb6Oz0YjepZIyWawsFMKSbJGBRNzVF3dSJCmCISGlqaIA3vxnWrh22XXZ0dOS9zezZs7n++ut7LTOQiwwREZFiaGppoyZmYLR3Ohu3bi92kwpH1xYFoQCGdLO2OU1VqpzJFeXUVado2LwNd0U+RaTEXHAB/OUv4bEAVq9ezT777MMZZ5zBAQccwMknn8zWrVuZO3cuX//61znyyCO57rrrePbZZ1myZAmHHHIIb3rTm3jqqacAeP755zn88MM59NBDOe+887rV+/rXvx4IFymf+9zn2H///TnggAP48Y9/zEUXXUR9fT3HHHMMxxxzDAB//OMfOfzwwzn44IM55ZRT2LJlCwC33nor++yzD0ceeSQ33HBDQY5bRESkv15pa2dLWzu1VSlqKlMAY2sgT11bFOS4ywtSi4wZ9ZvTzK6eCIQsjFe2d9Da1k5VanyRWyYiUiBHH73rsve8Bz7+cdi6FRYvhocegs5OuOQSeOQRWLoUzjwT1q+H7LTKFSv6tdunn36aSy+9lCOOOIKzzjqLn/70pwCkUin+8pe/ALB48WIuueQS5s+fz4MPPsjHP/5x7rrrLj71qU9xzjnncPrpp/OTn/wkZ/3Lly/n+eef55FHHqG8vJyNGzcyffp0LrzwQv70pz8xY8YM1q9fzze+8Q3uuOMOJk+ezHe/+10uvPBCvvCFL3D22Wdz11138ZrXvIZTTz21nydTRESkMJpaw6CdNZWhCwmEjIz9ZhezVf2ka4thu7ZQAEO6WduyjVlTQ8SzbmoIZDRsTlM1SwEMESkRL7wASeaZe/i7APbYYw+OOOIIAD7wgQ9w0UUXAXR9oG/ZsoX77ruPU045pWubtrZwMXfvvffym9/8BoAPfvCDfPGLX9yl/jvuuIOPfexjlJeHj/bp06fvUuaBBx7giSee6GrH9u3bOfzww3nqqaeYN28e8+fP72rf8uXLC3LcIiIi/ZEM2llbFbqQwBjKwNC1RcGuLRTAkG4aNqfZf/epAMyuDm8c9c3b2HtWZTGbJSJSOL19q9HcDJs2db/I2LQJliwJf8+Y0e9vRbKZWc6/J0+eDEBnZyfV1dU8+uij/do+m7v3q8zb3vY2rrnmmm7LH3300T63FRERGUqNSQZGVQUzK0MGxqiZSlXXFsN2baExMKRLekcHG17Z3pV5MSs+rtVAniJSKi64IKR3ZuroKEh/1RdffJH7778fgGuuuYYjjzyy2/qqqirmzZvHddddB4QLgr///e8AHHHEEVx77bUAXHXVVTnrP/bYY7nkkktob28HYOPGjQBUVlbS2toKwKJFi7j33ntZtWoVAFu3buVf//oX++yzD88//zzPPvtsV/tERESGU1cGRmWK8ePKmDFlAo2tY+A+RNcWXe0rBAUwpEtTjHAmXUhqKysoM2jYvK2YzRIRGT733w/bs0Y8374d7rtv0FXvu+++XHHFFRxwwAFs3LiRc845Z5cyV111FZdeeikLFixgv/3246abbgLgRz/6ET/5yU849NBDaW5uzln/Rz7yEfbcc08OOOAAFixYwNVXXw3A0qVLOf744znmmGOYOXMml19+OaeddhoHHHAAixYt4qmnniKVSrF8+XLe8Y53cOSRR7LXXnsN+nhFRETy0dTaxoTyMqomhk4CNZWprqDGqKZri4JeW1ipzTCxcOFCX7lyZbGbMSI98NwG3rv8AX754Tdw5PwZACz61p0cOX8G3z9lQZFbJyIyME8++ST77rtvUduwevVq3vnOd/LYY48VtR2FkOt8mtnD7r6wSE0qKl1XiIgUxqevfYSHX9zEn7/wFgA+9POHWL9lO7/7xJF9bDn8dG1RWPlcWxQlA8PMPmNmj5vZY2Z2jZmlzGyemT1oZs+Y2a/MbEIsWxH/XhXXz82o58tx+dNmdlwxjmUsSbqKJBkYye/qQiIiIiIiIkOpsaWta/pUCIN5jplBPKVghj2AYWa7A58EFrr764FxwHuB7wI/cPf5wCbgw3GTDwOb3P01wA9iOczsdXG7/YAlwE/NbNxwHstYU98cuorUZQQwZlenupaLiMjAzJ07d0x8QyIiIjJUmlrTXdOnAtRUpVi/pY32js5etipdpXptUawxMMqBiWZWDkwCGoC3ANfH9VcAJ8XfT4x/E9cvtjCc6YnAte7e5u7PA6uAw4ap/WPS2uY0ValyJlfsnJxmVtVEGjanKbWuRiIytug9rDB0HkVEZKg07ZKBUUGnw4ZXtveyVfHoM7Ew8j2Pwx7AcPeXge8DLxICF83Aw8Bmd2+PxdYAu8ffdwdeitu2x/K7ZS7PsY0MQENzumsGksTs6hTbdnTQsq29h61EREa2VCrFhg0bdKExSO7Ohg0bSKVSfRcWERHJw9bt7bS2tVOTkYFRG4MZI7Ebia4tCmMg1xblfRcpLDObRsiemAdsBq4Djs9RNHk25Jo81ntZnmufS4GlAHvuuWeeLS4dDc3bqKvu/uRJAhr1zduYOml8MZolIjIoc+bMYc2aNaxbt67YTRn1UqkUc+bMKXYzRERkjElmQ8weAwPC2Bgjja4tCiffa4thD2AAbwWed/d1AGZ2A/BGoNrMymOWxRygPpZfA+wBrIldTqYCGzOWJzK36cbdlwPLIYwWXvAjGiPWNqfZf/ep3ZYlA3qubU6zb11VMZolIjIo48ePZ968ecVuhoiIiPQgybLIHAMj+X0kZmDo2qJ4ijEGxovAIjObFMeyWAw8AfwJODmWOQO4Kf5+c/ybuP4uD7k6NwPvjbOUzAPmAw8N0zGMOW3tHazfsj1nFxJAA3mKiIiIiMiQaGoNWRZJ1gXAblMqKDNoGoEBDCmeYc/AcPcHzex64G9AO/AIITvi98C1ZvaNuOzSuMmlwC/MbBUh8+K9sZ7HzezXhOBHO3Cuu3cM68GMIY3N4U0jcwpVCGlc48qMhs164xARERERkcJLsixqKndmYIwrM2ZWVozILiRSPMXoQoK7LwOWZS1+jhyziLh7Gjilh3q+CXyz4A0sQbmmUIXwxlFTWUFDswIYIiIiIiJSeOta25hQXsbUid3H3KutStHYqvsQ2alY06jKCLM2Biiyu5CEZSka1IVERERERESGQGNLmprKCsIIAzvVVKaUgSHdKIAhAF0ZFtkZGAB11ROVgSEiIiIiIkOiqbWt2/gXidqqCo2BId0ogCFAmEK1KlXO5IpdexXVVYUMDM1zLCIixWRme5vZoxk/LWb2aTObbma3m9kz8XFaLG9mdpGZrTKzf5jZwRl1nRHLP2NmZ2QsP8TM/hm3uciyvw4UEZGCSzIwstVWpdjwyna2t3cWoVUyEimAIUDIwMjVfQRCBkZ6Ryebt+4Y5laJiIjs5O5Pu/uB7n4gcAiwFbgR+BJwp7vPB+6MfwMcT5ilbD6wFLgYwMymE8biegNh/K1lSdAjllmasd2SYTg0EZGS1lsGBsC6LepGIoECGAKEDIzsGUgSs6dqKlURERlxFgPPuvsLwInAFXH5FcBJ8fcTgSs9eACoNrM64Djgdnff6O6bgNuBJXFdlbvfH6dsvzKjLhERGQJbt7fTmm5nZo4MjJoY1GhUNxKJFMAQIAziObs6dwAjCWys1TgYIiIycrwXuCb+XuvuDQDxsSYu3x14KWObNXFZb8vX5FguIiJDpCkO0pkzA6MyFcvoPkQCBTCEtvYO1m/Zzqyq3F1IZleH5fUKYIiIyAhgZhOAdwHX9VU0xzIfwPLs/S81s5VmtnLdunV9NVdERHrR1BoCGLnHwAjLNBOJJBTAEBqbwxtCXQ8ZGDOmVFBeZjRsVhcSEREZEY4H/ubujfHvxtj9g/jYFJevAfbI2G4OUN/H8jk5lnfj7svdfaG7L5w5c2YBDkdEpHQl3UNyZWBMmzSB8eNMXUikiwIYQkMc2yLXFKoA48qM2qqUupCIiMhIcRo7u48A3AwkM4mcAdyUsfz0OBvJIqA5djG5DTjWzKbFwTuPBW6L61rNbFGcfeT0jLpERGQIJBkYSbZFprIyo6YypQwM6bLrnJlSchpiYKKnAEayToN4iohIsZnZJOBtwEczFn8H+LWZfRh4ETglLr8FeDuwijBjyYcA3H2jmV0A/DWW+7q7b4y/nwNcDkwE/hB/RERkiDS1pJlQXsbUieNzrq+pqqCpVV+kSqAAhnQFMGb1MI1qWJfiny83D1eTREREcnL3rcBuWcs2EGYlyS7rwLk91HMZcFmO5SuB1xeksSIi0qem1jZqKisIiW+7qq1M8dz6LcPcKhmp1IVEWNu8jcpUOVMqeo5nza6eSENzmnAtKCIiIiIiMniNLemcA3gmaqsq1IVEuiiAIdQ3p5ndS/YFhC4k29s72fjK9mFqlYiIiIiIjHVNrW05B/BM1FSlaN62g/SOjmFslYxUCmAIa5vTzOpl/AvYOT5GgwbyFBERERGRAuk7AyPVVU5EAQyhoXlbrwN4AtTFDA0FMEREREREpBC2be+gNd1OTS8ZGMnsJOpGIqAARslra+9g/ZbtXQGKntRVJxkYmolEREREREQGL5ldRBkY0l8KYJS4xuYQyewrA2PG5ArGjzNlYIiIiIiISEEkWRW9jYFRW6kAhuykAEaJSzIqkgyLnpSVGbVVKRo2KwNDREREREQGrysDo6rnDIyqieVUlJfR1KouJKIARslbGyOZfWVgAMyeOpF6ZWCIiIiIiEgBdGVgVPZ8L2IWvkhVBoaAAhglr35zeCOY1ccYGKFMirUKYIiIiIiISAE0taaZMK6M6knjey1XW1WhAIYACmCUvLXN26hMlTOlorzPsnXVIYDR2enD0DIRERERERnLmlramFlZgZn1Wq6mKkWTZiERFMAoefXN6X51H4HQhWR7RycbXtk+xK0SEREREZGxrqk13TVNam9qK9WFRAIFMErc2uZ0n1OoJmbFQIe6kYiIiIiIyGA1trRR08v4F4naqgpe2d7Blrb2YWiVjGQKYJS4hjwzMADqmzUTiYiIiIiIDE5TSz8zMKo0laoECmCUsLb2DtZvaet3BkYy1aqmUhURERERkcFI7+igJd1OTVXfX6Ym06wqgCEKYJSwZCCc/mZgTJ80gQnjymjQG4eIiIiIiAxCci9SU9n/DAwN5CkKYJSw+phJMaufAYyyMmPW1BQNmxXAEBERERGRgWtsDfcU/cnAUBcSSSiAUcLWxjeA2dX9C2BACHY0aAwMEREREREZhCSboj9jYEypKGfyhHE0KgOj5CmAUcIa4mwis/o5BgbA7Kmpru1EREREREQGIsmm6M8sJBCyMJKsDSldCmCUsIbN26hMlTOlorzf29RVT6SxJU1npw9hy0REREREZCxrbE0zfpwxbdL4fpWvqaqgSV1ISp4CGCUsnylUE3VTU+zocNZvUfqWiIiIiIgMzLqWNmoqU5hZv8rXVqXUhUQUwChlDc3pvLqPAF1TrqobiYiIiIiIDFRja7pretT+CAGMNO7KBC9lCmCUsIbmNLMHkIERttVAniIiIiIiMjBNLW3U9nP8CwjTrba1d9KyrX0IWyUjnQIYJaqtvYP1W9r6PYVqYmcAQxkYIiIiIiIyMI0t+WdgABrIs8QpgFGikmmLZufZhWT65AlUlJcpgCEiIiIiIgOS3tFBS7q9KyjRH10BDA3kWdIUwChRO6dQzS8Dw8yom5qifrO6kIiIiIiISP6SL1NnVuaTgRHKaiDP0qYARolKxrDIdxYSCEGPtcrAEBGRIjCzajO73syeMrMnzexwM5tuZreb2TPxcVosa2Z2kZmtMrN/mNnBGfWcEcs/Y2ZnZCw/xMz+Gbe5yPo7PL6IiPRbU+wGkk8GRk2lMjBEAYySlWRg1FXn14UEQrcTdSEREZEi+RFwq7vvAywAngS+BNzp7vOBO+PfAMcD8+PPUuBiADObDiwD3gAcBixLgh6xzNKM7ZYMwzGJiJSUJIuiJo8MjIkTxlGVKqdJAYySpgBGiWrYvI3KinKmVJTnvW1ddYq1LWk6OjWFkYiIDB8zqwKOAi4FcPft7r4ZOBG4Iha7Ajgp/n4icKUHDwDVZlYHHAfc7u4b3X0TcDuwJK6rcvf7PczTd2VGXSIiUiADycBIyqsLSWlTAKNENTSnqavOv/sIwKypE+nodNZv0ZuHiIgMq1cB64Cfm9kjZvYzM5sM1Lp7A0B8rInldwdeyth+TVzW2/I1OZaLiEgBNba0MX6cMW3S+Ly2q61KaRaSEqcARola25JmVp4zkCRmx3EzNJCniIgMs3LgYOBidz8IeIWd3UVyyTV+hQ9gefdKzZaa2UozW7lu3bq+Wy0iIt00taSpqUyR7zBDNVUVXQOASmlSAKNE1W9OdwUi8lUXAx8aB0NERIbZGmCNuz8Y/76eENBojN0/iI9NGeX3yNh+DlDfx/I5OZZ34+7L3X2huy+cOXPmoA9KRKTUNLW25TUDSaK2KkVTa5pOdWUvWQpglKDt7Z2s39KW9xSqiWTmEgUwRERkOLn7WuAlM9s7LloMPAHcDCQziZwB3BR/vxk4Pc5Gsghojl1MbgOONbNpcfDOY4Hb4rpWM1sUZx85PaMuEREpkMaWdNe0qPmoraxgR4ezaev2IWiVjAb5j+Aoo14y9dBAplAFqJ40ntT4MhrUhURERIbfJ4CrzGwC8BzwIcIXMr82sw8DLwKnxLK3AG8HVgFbY1ncfaOZXQD8NZb7urtvjL+fA1wOTAT+EH9ERKSAmlrbOPzVu+W9XTLoZ2NLG7tNyT8AIqOfAhglqGsK1QGOgWFm1GkqVRERKQJ3fxRYmGPV4hxlHTi3h3ouAy7LsXwl8PpBNlNERHqQ3tFB87YdeU2hmqhJAhitaV5HVaGbJqOAupCUoIbmkDkx0AyMZNukHhERERERkf5Y1xoG4azJcwpVoKvbSVOLvkgtVQpglKCuDIzqgWVgAMrAEBERERGRvCXd2QeSgZEM/NmomUhKlgIYJWhtc5rKinKmVAy8B1Hd1BSNLWnaOzoL2DIRERERERnLmmIGRu0AMjAqyscxffKEriCIlB4FMEpQ/eZtA56BJFFXnaLTYd0WRT9FRERERKR/BpOBkWynDIzSpQBGCVrbkh5U9xGA2XEA0PrNin6KiIiIiEj/NLW2MX6cMW3ShAFtX1uVoqlV9yClSgGMElS/OU3dAFK2MiUZHGs1DoaIiIiIiPRTY0uamVMqKCuzAW1fW1WhLiQlTAGMErO9vZP1W9qoqx5cACPJwNBMJCIiIiIi0l/rWtsGNANJorYqxbrWNjo6vYCtktFCAYwSk0QrBzOFKkDVxHImTRinLiQiIiIiItJvjS3pAY9/AWH61U6HDRqLryQpgFFikqlPZ00d3BgYZsasqSnWtigDQ0RERERE+qexpW1AM5AkajWVakkrSgDDzKrN7Hoze8rMnjSzw81supndbmbPxMdpsayZ2UVmtsrM/mFmB2fUc0Ys/4yZnVGMYxltki4fsweZgRHqmKgMDBERERER6Zf0jg6at+2gtmrgGRhJ8EPjYJSmYmVg/Ai41d33ARYATwJfAu509/nAnfFvgOOB+fFnKXAxgJlNB5YBbwAOA5YlQQ/p2c4MjMEHMOqmpjQGhoiIiIiI9Mu61pA1UVM5uDEwABo1E0lJGvYAhplVAUcBlwK4+3Z33wycCFwRi10BnBR/PxG40oMHgGozqwOOA253943uvgm4HVgyjIcyKq1tTlNZUU5lavyg66qbmqKptY0dHZ0FaJmIiIiIiIxlyfSnNYPIwJgxZQJm6kJSqoqRgfEqYB3wczN7xMx+ZmaTgVp3bwCIjzWx/O7ASxnbr4nLelouvWho3laQ7AuAuuqJuIe5nEVERERERHqTBB0Gk4FRPq6MGVMqaFIXkpJUjABGOXAwcLG7HwS8ws7uIrnkmiDYe1m+awVmS81spZmtXLduXb7tHVMamtPUVQ9uAM9EEghp2KxuJCIiIiIi0rsk6DCYMTCS7TUGRmkqRgBjDbDG3R+Mf19PCGg0xq4hxMemjPJ7ZGw/B6jvZfku3H25uy9094UzZ84s2IGMRg3NaeoGMepvptlxJpNkXA0REREREZGeNLa2UV5mTJs0YVD11Fam1IWkRA17AMPd1wIvmdnecdFi4AngZiCZSeQM4Kb4+83A6XE2kkVAc+xichtwrJlNi4N3HhuXSQ+2t3eyfktbAbuQxAwMDeQpIiIiIiJ9aGppo6aygrKyXMn0/VdTleoaT0NKS3mR9vsJ4CozmwA8B3yIEEz5tZl9GHgROCWWvQV4O7AK2BrL4u4bzewC4K+x3NfdfePwHcLo09iSxh1mVxcmgFFZUc7kCeM0laqIiIiIiPSpqTXNzAJkg9dWVbB+y3Z2dHQyflyxJtaUYihKAMPdHwUW5li1OEdZB87toZ7LgMsK27qxa21LMoVqYcbAMDPqqieyVl1IRERERESkD00tbey126RB15NMpbqutY3ZBRrfT0YHhatKSH0cbHN2gbqQQJhKVV1IRERERESkL42t6UFNoZpIBgHVQJ6lRwGMEpJkShRqDAwIAYx6ZWCIiIiIiEgv0js62Lx1B7WDmEI1kUzDqoE8S48CGCWkoTnNlIpyKlPjC1Zn3dSJrN/Sxvb2zoLVKSIiIiIiY8u61hBsKEwGRghgaCDP0qMARglpaN5GXQGzLyAMCOqu9C0REREREelZEmyoKcAgnrtNnsC4MtM9SAlSAKOENDSnC9p9BHYOCNqgbiQiIiIiItKDptjdoxBdSMrKjJrKCnUhKUEKYJSQhuY0sws0A0kiGRBUA3mKiIiIiEhPkmyJQnQhgdCNRBkYpUcBjBKxvb2T9VvaCp6BUVetDAwREREREeldU2sb5WXG9EkTClJfbVVFV1aHlA4FMEpEY0sadwo+BsaUinIqK8q7ZjgREREZSma22sz+aWaPmtnKuGy6md1uZs/Ex2lxuZnZRWa2ysz+YWYHZ9RzRiz/jJmdkbH8kFj/qritDf9RioiMPY0tbcysrKCsrDBvq7VVKRo1iGfJUQCjRKyN6VVJxkQh1VWnqN+sLiQiIjJsjnH3A919Yfz7S8Cd7j4fuDP+DXA8MD/+LAUuhhDwAJYBbwAOA5YlQY9YZmnGdkuG/nBERMa+ptZ0QQbwTNRWpdi8dQfpHR0Fq1NGPgUwSkQSYCh0Bkaoc6K6kIiISDGdCFwRf78COClj+ZUePABUm1kdcBxwu7tvdPdNwO3Akriuyt3vd3cHrsyoS0REBqGppY2aysKMfwF01ZVMzyqlQQGMEpF08RiaAEZKAQwRERkuDvzRzB42s6VxWa27NwDEx5q4fHfgpYxt18RlvS1fk2O5iIgMUlNrmtoCDeAJIQMD0ECeJaa82A2Q4dHQnA7jVaTGF7zuuqkTWb+ljbb2DirKxxW8fhERkQxHuHu9mdUAt5vZU72UzdXR2gewvHulIXCyFGDPPffsu8UiIiWurb2DTVt3UFOAKVQTOwMYysAoJcrAKBENzdsKPgNJIsnqaGzWm4eIiAwtd6+Pj03AjYQxLBpj9w/iY1MsvgbYI2PzOUB9H8vn5Fie3Ybl7r7Q3RfOnDmzEIclIjKmJbOFFDYDI9SlDIzSogBGiVjbnB6S7iMQBvGEECQREREZKmY22cwqk9+BY4HHgJuBZCaRM4Cb4u83A6fH2UgWAc2xi8ltwLFmNi0O3nkscFtc12pmi+LsI6dn1CUiIgPUFMepKGQGxtSJ45lQXqaZSEqMupCUiPrmNHvPqhySuuumhplNNA6GiIgMsVrgxjizaTlwtbvfamZ/BX5tZh8GXgROieVvAd4OrAK2Ah8CcPeNZnYB8NdY7uvuvjH+fg5wOTAR+EP8ERGRQWiKWRI1BczAMDNqqyq6sjukNCiAUQK2t3eyfktbV6Ch0JLMjnplYIiIyBBy9+eABTmWbwAW51juwLk91HUZcFmO5SuB1w+6sSIi0iXJwKgt4DSqALWVKXUhKTHqQlICmlrTuA/NDCQAOthUMgAAIABJREFUkyvKqUqVd810IiIiIiIikmhsSVNeZkyfNKGg9dZWKYBRahTAKAFJ14666qHJwACYXT2R+s168xARERERke6aWtuYWVlBWVmuyZ4GrkZdSEqOAhgloCuAMUQZGACzpqY0iKeIiIiIiOyisSVNTWXhxr9I1FalaG1r55W29oLXLSOTAhgloGFzCCwM1TSqEAbyVBcSERERERHJtq61jZoCj38BO6dSTcbYkLFPAYwS0NCcZkpFOVWp8UO2j9lTU2x4ZTvpHR1Dtg8RERERERl9hiwDI07LqnEwSsegAhhmdkrGfOxfNbMbzOzgwjRNCqWheduQZl/AzuwOZWGIiEhfdP0gIlI62to72LR1R8FnIAG6sjoUwCgdg83AOM/dW83sSOA44Arg4sE3SwppbXN6SMe/gDCIJ+wcb0NERKQXun4QESkR62L3jqEZAyN2IdFAniVjsAGM/5+9O4+P6ywPPf57ZzTSyNpt7ZJH3hUviWMpsZ2E4BCWBAiJKQFC0pZygRRaLlBuU5J7S7kQaEMDhV4KFEqhQPatSUggaRqSACGRY0mJbdnxEtuSpZE0spYZbTPSzLz3jzNHlh2vmuWcM3q+n898JJ1ZzjvJWDrnOc9i1gu8F/iB1voxILWzcUTSejMQwDBfXxp5CiGEOAty/CCEEPOE2Z8iHRkYhXk5LMh1SwbGPJJsAKNHKfVD4EPAr5RSeSl4TZFCU9E4A2MRqkvSN0IVjCaeIBkYQgghzoocPwghxDwRSAQXKtKQgaGUoqrYS7808Zw3kj1Y+BDwNHC11noEWAjckvSqRMoERsNobTTZTKf8XDelCzySgSGEEOJsyPGDEELME/2h9GVggFGaIhkY80dOMk/WWk8opQLAW4D9QDTxVdiEmRGR7iaeYGRh9I7ILw/hHI+293Dn03vxj0xSW5rPLVc1snVDndXLEiLryfGDEELMH4HRMG6XYlFBeioFq4q97OgeSctrC/tJKoChlPoycBHQCPwU8AB3AZclvzSRCmYAw2yymU41JV4pIRGO8Wh7D7c9spPJxOjfnpFJbntkJ4AEMYRIMzl+EEKI+aM/FKGiMA+XS6Xl9auK8+gPRdBao1R69uEU8+HiXLIlJO8HrgXGAbTWfqAo2UWJ1OlLlHRkJgPDKyUkwjHufHrvTPDCNDkd486n91q0IiHmFTl+EEKIeSIwGpmZFpIOVcVeJqdjjEaiaduHE5gX53pGJtEcuzj3aHuP1UtLqWQDGFNaaw1oAKVUQfJLEqnkHwlTkOumKC+pZJuzUlPiZXhimsmp2JkfLITF/CMnD7adarsQIqXk+EEIIeaJQChMRVH6LqZWJnprBOZ5H4z5cnEu2QDGA4ku4qVKqU8C/w38W/LLEqnSFwxTU5qfkXQqcxJJ3zz/5SGc4VRlVQvy3ERj8QyvRoh5R44fhBBinkh7BkZiuonZLHS+mi8X55IKYGitvwk8BDyMUcf6d1rr76ZiYSI1eoOT1GSgfASgptTYT2+W/SMR2emWqxrJyzn+V6DbpRiPxPizn75CcGLaopUJkf3k+EEIIeaHqWicofEpKtOYgWFON5nvk0hOdXEuE70QMynpmeta62e01rdorf9aa/1MKhYlUqc3GM5cACORgeGXRp7CAbZuqGPrhbUAKKCuNJ9vfXA9//iBC2g5NMjW77/IgcCYtYsUIovJ8YMQQmS/gTFzhGr6MjAqiyUDA4yLc/me40/v8z1ubrmq0aIVpcecGiMopUZJ1K2eeBegtdbFSa1KpMR0LM7AWITqksxE3cxASZ808hQOkZvjpjAvhx1fftdxnbGXVhTwqV+08v7vv8h3P7KBKxorLVylENlDjh+EEGJ+MbMiKtMYwFiQm0ORN2feZ2Bs3VDH4FiE25/cM7Ptr9+1SqaQAGiti7TWxSe5FcnBh330h8JoTcYyMLweNwsLciUDQzhGhz/ImpriN431unjJQh77zGXUly3gf/zHK/z4dwcx+g0KIZIhxw9CCDG/BBJZEeksIQGjjCQwKucgCwtzAfj+TU0A5OYkXXBhOyl5R0qpSqWUz7yl4jVF8voSgYRMBTAAqou90gNDOEIsrtnTO8raupOfM9WXLeChT13CO9dU8bUn9/DFh3cQicqEHSFSSY4fhBAiu5lBhXRmYIBRojLfS0gAWjuHKczL4aq11fgWLuCFfQNWLynlkgpgKKWuVUrtBw4BLwCHgV+nYF0iBfwzAYzMNW6pLfXSKxkYwgEOHR1jcjrG2tqSUz6mIC+HH9zUzGevXMED27v54x+3cHRM/jgKkSw5fhBCiPmhPxTG7VIsKkhzAKPIO+9LSABaO0fY4CvF7VJsWVXBH94YzLoLcMlmYNwObAb2aa2XAm8HXkx6VSIlzF4U5nSQTKgpyZcAhnCEXT0hANadIgPD5HIpvvCuRr77kQ3s6A5y3b+8yG5/KBNLFCKbyfGDEELMA4FQhPLCXNwnlOumWmWxl0AoMq9LfkfD0+ztC9HkKwNgy6oKJqZibD88bPHKUivZAMa01noQcCmlXFrr54ALU7AukQL+kTAFuW6K8ubUq3VOqku8BCenmZiKZmyfQsxFhz9Ibo6L5RWFZ/X4962v5aFPXUosrrn+X//AU7v60rxCIbKaHD8IIcQ80D8amRlzmk5VxXlMxeKMTEynfV929dqRIHENzQ1GAOOS5YvIdbuyrowk2QDGiFKqEPgtcLdS6p8BOXO1ib5gmJrSfJRKb8RzttpEtodkYQi76/CHOK+6CI/77H8Nnl9fwuOfuYyVVUV86q5Wvvvs/nkd6RciCXL8IIQQ80AgFE57A09gJkjSP48bebZ2DqMUXOgrBYxS6IuXlvHCXglgzHYdMAH8FfAU8AbwvmQXJVKjNxTOaANPONZvo3dk/v7yEPantWZXT/C0/S9OpbLYy/03b+b9G+r41jP7+Ox9rzI5lV21hUJkgBw/CCHEPBAYjaS9gScYGRjAvG7k2do1TGNVEcVez8y2Lasq2Ns/ij+LhiykZAqJ1joKvITRhEuKw22id2SS6gykbM1mBkz8wez5RyKyT/fwJKFwlLW1c5va6PW4+acPreeLV5/HEzv8fOiHL81M/RFCnD05fhBCiOw1FY0zND5FVQYyMMwsj/nayDMe17R3DdOUKB8xXdFYCcBvs6iMJNkAxm8Br1KqDngW+BjwH8kuSiRvOhZnYCxCTWnmJpCA0QMDkJM5YWsd/iAA6+rOPQPDpJTi01cs59/+5CIODozxvn/5Pe1d2dUkSYg0mvPxg1LKrZRqV0o9kfh5qVKqRSm1Xyl1v1IqN7E9L/HzgcT9S2a9xm2J7XuVUlfN2n51YtsBpdStKXu3QggxDw0kJrdlIgPD3EdgngYwDgyMMRqOzjTwNK2sLKSmxJtVfTCSDWAorfUE8EfAd7XW7wfWJL8skaz+UBityXgJSV6Om/LCXHolA0PYWIc/hNulOK+6KOnXeseaKh75i8vIy3Hx4R+9zKPtPSlYoRBZL5njh88Be2b9/A3g21rrlcAw8PHE9o8Dw1rrFcC3E49DKbUGuAFYC1wNfD8RFHED3wPenVjLRxKPFUIIMQdmMKEqAwGMvBw3ZQs887aEpLXTuIjWfEIGhlLGONXf7z/KdCxuxdJSLukAhlLqEuAm4MnEtsyNvBCnZGZAZDqAAUYWhjTxFHbW4Q+xvKIAr8edktdrrC7i8c+8hQ2LS/n8/a/yjadeJx6X5p5CnMacjh+UUvXAe4Efmy8CXAk8lHjIz4Ctie+vS/xM4v63Jx5/HXCf1jqitT4EHAA2Jm4HtNYHtdZTwH2Jxwoxbzza3sNld/yGpbc+yWV3/EaC8iIpZjAhE008wWjkOV9LSFo7h1lYkMuSRQvedN8VjRWMRqK0d41YsLLUSzaA8TngNuA/tdYdSqllwHPJL0skq3cmgJHZEhJzn9LEU9jZrp4g6+bQwPN0Fhbk8ouPb+IjG3384Pk3uPkXrYxFZKiCEKcw1+OH7wB/A5iXkRYBI4leGgDdQF3i+zrgCMz02ggmHj+z/YTnnGr7myilblZKbVdKbR8YyJ60XDG/Pdrew22P7KRnZBIN9IxMctsjOyWIIeZsIDERJBMlJMZ+vPSPzs8MjLbOYZp8ZSedPnnpinLcLsUL+wIWrCz1kgpgaK1/q7W+Vmv9jcTPB7XWn03N0kQyzBKOagsyMGpKvNLEU9hWYDRMYDTCmjk28Dyd3BwXf//+dXzl2rU8tzfAB77/B44MTaR8P0I43VyOH5RS1wABrXXr7M0ne/kz3Heu29+8Uesfaa0v0lpfVFFRcZpVC+Ecdz69l8np46dqTU7HuPPpvRatSDhdfyiCS8GigswEMKqK8uZlD4yh8SkOHh1/U/mIqdjrodlXxvNZMk41JVNIhP30BsMU5Lop9ma+oqemJJ/RcFSuPgtb6vAbgw6SaeB5OkopPnrpEn72sY30Bie59l9+z8sHB9OyLyHmmcuAa5VShzHKO67EyMgoVUqZf+zqAX/i+25gMUDi/hJgaPb2E55zqu1CzAunGrOYTeMXRWb1h8JUFOXhdp0sPpx6VcVeAqOReVfG23aK/hezbWmsoMMfIjDq/ACPBDCyVO9ImOoS70nTiNKtttScRCJ/8IT97E4EMNKRgTHbW1aW89hn3kJZQS5//OMWbnnoNakrFiIJWuvbtNb1WuslGE04f6O1vgmj9OT6xMM+CjyW+P7xxM8k7v+N1lontt+QmFKyFFgJbANeAVYmpprkJvbxeAbemhC2UHuKyXWn2i7EmQRGIxnrfwFGs9BYXDM4PpWxfdpBa9cwOS7FBfWnvji3ZZWRLfi7fUcztay0SSqAoZS67Gy2iczrDYUt+4NTXWz8ovJLHwxhQx3+IA2LFlDs9aR9X0vLC/jPv7iMFZWFPLi9W+qKhUhI8fHDF4EvKKUOYPS4+PfE9n8HFiW2fwG4FUBr3QE8AOwGngL+UmsdS/TJ+AzwNMaUkwcSjxViXrjlqkZy3cefGuR73NxyVaNFKxJO1x8KZ2QCiakycQ4y3xp5tnUOs7au5LTN6dfUFFNemJcV41STzcD47lluExnWF5ycCSRkmhk46ZNJJMKGdvWEWJvm7IvZSvI9hMLTb9oudcVinkvq+EFr/bzW+prE9we11hu11iu01h/UWkcS28OJn1ck7j846/lf11ov11o3aq1/PWv7r7TWqxL3fT2J9yeE42zdUMd5NYWY2f45LsU//NH5bN1w0l62QpzRwGhkJqiQCVWJfWVDmcTZmo7Fea17hCZf6Wkf53IZ41R/u3+AmMNLbObUICEx+uxSoEIp9YVZdxUDqZlLKOZsOhYnMBqxZIQqHPvlIY08hd0EJ6fpGprgwxcvPvODU+hUU3mkrljMN3L8IIR99YfCdPhH+cTlyyhd4OEfn9o7k3YuxLmaisYZHJ+isihzGRhmtoc5vnU+2NMbIjwdP23/C9OWxgoebutmR/cIG3xnfrxdzTUDIxcoxAiAFM26hThWhyosEhiNoDXUWFRCkpvjorwwT0apCtsx+19kMgMDpK5YiFnk+EEIm3rglSPE4pobN/poSpzctB8ZtnhVwqmOjhlBhKoMZmCUF+ah1PwqIWk9iwaepstXlKMUji8jmVMGhtb6BeAFpdR/aK07U7wmkaTeEetGqJpqS730zqNfHsIZOvxBANbWpmcCyancclUjtz2y87jxdPkel9QVi3lHjh+EsKdYXHPvti4uX1nOkvICKouNyRFtnSNceV6V1csTDmQGETKZgeFxu1hUkDevMjBaO4epLfFSU3Lmi2JlBbmsry/l+b0DfP4dqzKwuvSYUwaGUuo7iW//RSn1+Im3s3wNt1KqXSn1ROLnpUqpFqXUfqXU/YkO4CS6hN+vlDqQuH/JrNe4LbF9r1Lqqrm8l2zUm+g9UXsWH+R0qSnxzgRShLCL3f4QVcV5VGTwjykYdcX/8EfnUzcr4+KTb10mdcVi3knF8YMQIvWeez2APxjmpk0+ABbk5rC6poi2LsnAEHMTGM18BoaxvzwC8+gialvnME1nkX1huqKxgte6Rxh28KSWOWVgAL9IfP1mEvv+HEaXbzOX+xvAt7XW9yml/hX4OPCDxNdhrfUKpdQNicd9WCm1BmPE2VqgFvhvpdQqrXXsxB3NN71B6zMwakryefHAoGX7F+JkdvmDGc++MG3dUMfWDXVMTEXZ9PVnOTIkAT4xL6Xi+EEIkWJ3t3RSWZTH21cfy7Zo8pXxcGs3sbjGbXb2dKhH23u48+m9+EcmqS3N55arGuUiQpoFLMjAACNg0j9Pmnj6RybxB8N88hwCGFtWVfCd/97P7w4c5dr1tWlcXfrMKQNDa92a+PrCyW5ner5Sqh54L/DjxM8KuBJ4KPGQnwFbE99fl/iZxP1vTzz+OuA+rXVEa30IOABsnMv7yTa9wTAFuW6KvXONTyWvpsTLWCTK6EmmLwhhhcmpGAcCYxnvf3GiBbk5bN1Qx5M7ex0d/RZiLpI9fhBCpN6RoQme3zfADRcvxjNrjGqTr4zxqRh7+0YtXF3yHm3v4bZHdsoo8wwLjEZwKVhUmOkAxvwpITEzpM6m/4XpgvpSyhZ4eH5vIF3LSrukxqgqpS5TSj2jlNqnlDqolDqklDp45mfyHeBvgHji50XASGIGO0A3YIZF64AjAIn7g4nHz2w/yXPmtb5gmOoSL0acxxpmA9FeGaUqbOL1vhBxnfn+Fydz4yYfU9E4D7d1W70UISyRxPGDECLF7nulCwXcsNF33HazkafTy0jufHrvcT2oQEaZZ0J/KEx5YV7Gs3cqi7wcHYsQjcXP/GCHa+0cxutxsbrm7C/OuV2Ky1dW8Nt9R4k7dJxqUgEM4N+BfwLeAlwMXJT4ekpKqWuAgHkVxtx8kofqM9x3uuecuM+blVLblVLbBwac3XX1bPiD4bNq5JJO5ghXGRMp7KLDogkkJ7O6ppgmXyn3bOtCa2f+8RAiSed8/CCESL2paJz7X+nmyvOq3jQZa/HCfMoLcx0fwDjVsagco6ZXYDSS8f4XYJSQaA1Hx7I/y7Wta4T19aXHZU6djS2rKjg6FmF3byhNK0uvZAMYQa31r7XWAa31oHk7w3MuA65VSh0G7sMoHfkOUKqUMmse6gF/4vtuYDFA4v4SYGj29pM85zha6x9prS/SWl9UUZH986z7gpMzAQSrmPvvkwwMYRMd/iAl+R7qy+wxuvTGTQ0cHBjn5YNDVi9FCCvM5fhBCJFi/7W7j6NjEW7a7HvTfUopNvjKaO8asWBlqSOjzK3RH4pkvP8FGCUkxv6z+xwkPB2joyd4Tg08TW9dZZwPO3WcarIBjOeUUncqpS5RSjWZt9M9QWt9m9a6Xmu9BKMJ52+01jcBz3FsBvxHgccS3z+e+JnE/b/RxiXLx4EbElNKlgIrgW1Jvh/Hm47FCYxGLA9gVBV7UcrIBhHCDjr8IdbWFltaWjXbNRfUUOzN4Z5tXVYvRQgrnPPxgxAi9e5+uYv6snzeuvLkF/iafGUcOjrOkIN7Nt1yVSMe9/F/+/M9bhllnmaBUJhKizIwIPsDGDu6g0TjmmbfuQcwKoryWFdXzAt7nRnASLbL46bE14tmbdMYWRXn6ovAfUqprwHtGOmlJL7+Qil1ACPz4gYArXWHUuoBYDcQBf5SJpAY6VpaH+tBYRWP20VFYR59QUnPE9abjsV5vW+Uj17SYPVSZng9bj7QXM9dL3dydGwN5RluciWExVJ5/CCEmIMDgTFeOjjI31zdeMo+BU2+UgDau4aPm1DiJFs31HH/9i5eesPIeCzJz+Er166TKSRpNB2LMzg+ZUkGRqWZgTGa3Y08WzuN0q65ZGCAUUbyry8cJBSeptjrSeXS0i6pAIbW+m1JPv954PnE9wc5yRQRrXUY+OApnv914OvJrCHb9NlghKqppjRfmngKWzgQGGMqGmddnfUNPGe7aZOPn754mIdau/nUluVWL0eIjEn2+EEIkbx7t3XhcSs+2Lz4lI+5oL6UHJeizcEBDIBAKMIVjRXs6xuleclCCV6k2UAieGBFD4xFBUbj0ECWZ2C0dg6zrLyAhQW5c3r+llWVfO+5N3hx/1HefX5NileXXkkFMJRSf3ey7VrrrybzumLu/CPGP1arS0gAaoq97A84e/SWyA52auA524rKIjYuWci927q4+fJluDLcqVsIq8jxgxDWCk/HeKi1m6vWVlNxmqvk+bluVtcU09bp3D4YR8civDEwzvXNiynMy6Gt09lNSZ0gMBPAyHwGhtulqCjMy+oSEq01bV3DXHle5Zxfo8lXSpE3hxf2DTgugJFsD4zxWbcY8G5gSZKvKZJgNs20egoJQE2pl95gWKYsCMvt6gmS73GztLzQ6qW8yU2bfXQOTvDiG0etXooQmSTHD0JY6IkdvQQnp7lp05lLK5t8pbx6ZMSxYym3HTJKRzYtW0hzQxk9I5P0SolzWpnBg8oiay6oVhXn0R/K3hKSw4MTDI1P0TzH8hGAHLeLt6wo54V9A447V0sqgKG1/tas29eBKwDJybKQPzjJglw3xd5k25skr7Ykn4mpGKFw1OqliHlutz/E6pqijM8iPxtXr6umbIGHe1qkmaeYP+T4QQhr3d3SyfKKAjYvW3jGxzY1lDE5HeP1Pmdm1bYcHCTf4+b8upKZEz4nZ5Q4gZUZGACVxd6szsAw+18kE8AAow9GbzDMvv6xVCwrY5LNwDjRAmBZil9TnIO+YJiaEq8tJi2YfTgkyi2sFI9rdveGbNf/wpSX4+b65nqe2d2f9fWaQpyGHD8IkSEd/iDtXSPctKnhrI4XmxJTDtq7nFl60XJoiOaGMjxuF6trivF6XDMngCI9AqEwLgWLLGpQbmRgZO8xVVvXMEXeHFZUJJdZvKXRHKcaSMWyMiapAIZSaqdSakfi1gHsBf45NUsTc9EbDNuifASgttQMYGTvLxBhf51DE4xForbrfzHbRzb6iMY1D2w/YvVShMgIOX4Qwjr3tHSRl+PiA031Z/X4+rJ8ygvzaOtyXtbCyMQUr/eNsmmpkWnicbu4oL6UVocGY5wiEIpQXphnWeZrVZGX4YlpItHsHFDZ1jlMk68s6d5pNSX5NFYV8cI+Z41TTbbO4JpZ30eBfq211AtYqDc4yeWnmOWdaWYgpXdEAhjCOh3+IABra+2ZgQGwrKKQS5cv4t5tR/j0FStsWeoiRIrJ8YMQFhiLRHm0vYf3ra+lZMHZjU5UStHcUEqbA0/6j/W/WDSzrbmhjH/77UHC0zG8HrdVS8tq/aPhmXGmVjCnnwRCERYvXGDZOtIhFJ5mb/8o716XmsabWxor+I8XDzMeiVKQZ30LgrORbA+Mzlm3Hjn4sNZ0LE5gNEKtDSaQAFQW5eFSUkIirLWrJ4THrVhZZb8GnrPduMlHz8gkv93vrCi4EHMhxw9CWOPR9h7Gp2LctMl3Ts9r8pXROTjB0TFnNUZsOTREbo6L9YuPXcRo9pURjWt2dActXFl2C4QiVFnUwBOYCZ4ERrPvIuqrXSNonXz/C9MVqyqYisV56Y3BlLxeJqS6B4awUGA0gtZQbZMSkhy3i8oir5SQCEt1+IOsrCwiL8feV1netaaa8sJcaeYphBAiLbTW3N3SxZqaYi5cXHpOz21qMPtgOKuMpOXQIBsWlx53DGC+F+mDkT4Bm2RgZOMkktbOYVyK44JyyWheUsaCXLejykgkgJFF+hKZDjWl9sjAAHOUqmRgCGtordntD7Guzr79L0y5OS4+eNFint3TL/9mhBBCpFz7kRH29Ib4481n17xztvPrSshxKUeVkYTC0+z2h44rHwFYWJDLsvICCWCkyXQsztGxKctGqMLsAEb2XURt6xqmsbqYIu/ZlYCdSV6Om0uXL+L5fQHHjFOVAEYW8Sd6TdTYpIQEjLVIDwxhlb5QmMHxKVv3v5jtIxf7iGu4/xVp5imEECK17n65i8K8HK69sPacn+v1uFlbW0ybg076Ww8PE9eweembR8U2NZTR1jXsmBM2JzHLjKzMwChb4MHjVlmXgRGLa9q7RmhuOLcMqjPZ0ljJkaFJDh0dT+nrposEMLJIX6JUo6bYHiUkYDTy7A2G5Q+EsERHTwjA1hNIZvMtWsDlK8u5/5UjRGNxq5cjhBAiS4xMTPHEDj9bN9RSOMdGfRt8ZezoDjrm79PLhwbxuBUbfG/uFdDcUMbQ+BSHBycsWFl2M4MGVvbAUEpRWeTNuvH0+/pHGYtEU9b/wrRlpTlO1RllJBLAyCK9wTALct0U59ung2xNiZfJ6RjByWmrlyLmoV3+IErB6hpnBDAAbtrUQG8wzHN7nfFHRAghhP091NpNJBrnxo0Nc36NpoYyJqdjvN43msKVpU/LwSEuqC8lP/fNPbCapQ9G2phBA7OMwypVxXn0Z1kTT/Pz2ux7c1ZRMnyLFrCsvEACGCLzeoOTVJd4z7muMZ3MUap+KSMRFujwh1haXuCYsVAAb19dSWVRHve0dFq9FCGEEFlAa809LV00+UpZk0RGYpPPSFt3Qh+M8UiUXT1BNp2kfARgRUUhRd4cCWCkQf+o9SUkYARQsq2EpK1rmPLCPBYvTH22/VtXVfDSG4OEp2Mpf+1UkwBGFukNhqm1yQQSk9lQtC8kTQlF5u32h1jnkP4XJo/bxYcvXszz+wboHpbUViFmU0p5lVLblFKvKaU6lFJfSWxfqpRqUUrtV0rdr5TKTWzPS/x8IHH/klmvdVti+16l1FWztl+d2HZAKXVrpt+jEKn20sFBDh4d5483zz37AqCuNJ/KojxH9MFo6xomGtdvauBpcrkUTb4yR7wXpxkIhXEpWFSQa+k6jABGdl1AbescprmhNC0Xq69orCASjdNyaCjlr51qEsDIImYGhp3USgaGsMjw+BQ9I5OO6X8x2w0bfSjgvm3SzFOIE0SAK7XW64ELgauVUpuTShkJAAAgAElEQVSBbwDf1lqvBIaBjyce/3FgWGu9Avh24nEopdYANwBrgauB7yul3EopN/A94N3AGuAjiccK4Vh3v9xF6QIP7zm/JqnXUSpx0u+AUaotB4dwu9RpewU0N5SxLzAqZc4p1h+KsKgwjxy3taeZlcV5jIajTExFLV1Hqhwdi3B4cIKmk/R0SYXNyxaRl+PiBQeUMEsAI0tMx+IERiPU2iyAUVGUh9ulZhqMCpEpHX6zgaezMjDAuMp1RWMl928/wrRDmqUJkQnaMJb40ZO4aeBK4KHE9p8BWxPfX5f4mcT9b1fGpavrgPu01hGt9SHgALAxcTugtT6otZ4C7ks8VghHCoyGebqjj+ub6vF63twL4lw1NZTSNTQxM2nCrloODbKutvi0DUubG8rQGl49Yv+AjJMERsNUWVw+AseaiAaypIzEzBZKdQNPk9fjZtMyY5yq3UkAI0sMjEbQGqptVkLidimqivLwB6WERGTWLn8QcM4EkhPduNHHwGiEZ/f0W70UIWwlkSnxKhAAngHeAEa01uZltm6gLvF9HXAEIHF/EFg0e/sJzznVdiEc6cHt3UTjmo9s8qXk9cyrv3YuvQhPx3jtSPCU5SOm9YtLcSlp5Jlq/aEIlRZOIDGZTUSzpYyktWsYj1uxri59F+auWFXBwYFxjgzZu4RZAhhZojcRIKixWQYGQHWJl14pIREZ1uEPUVeaT5nFNZhz9bbzKqkt8XJ3S5fVSxHCVrTWMa31hUA9RsbE6pM9LPH1ZIXCeg7bj6OUulkptV0ptX1gwP7ptmJ+isWN5p2XLl/E8orClLzmuroSPG5l6zKS9q4RpmLxUzbwNBXm5XBedbGtgzFOFBiN2CMDI7EGs6mo07V1DrOuriQlmVSnsqXRGeNUJYCRJXoTJRpm00w7qSnNpy9Lop/COTr8QcdmX4CRvfThi338bv9ROgfHrV6OELajtR4Bngc2A6VKKTNXvB7wJ77vBhYDJO4vAYZmbz/hOafafuK+f6S1vkhrfVFFRUWq3pIQKfXbfQP0jEwm3bxzNq/HzZraEltPImk5NIhScNGSM4+abG4oo71rmFj8TXFKMQfRWJzB8QgVNsjAqCw2S0icfw4yFY3zWneQ5jT1vzAtKy+gviyf523eB0MCGFnCzHCoKbZXCQlAbYkX/8gkWssfB5EZ45Eoh46OO7L/xWwfvngxbpfiXmnmKQQASqkKpVRp4vt84B3AHuA54PrEwz4KPJb4/vHEzyTu/402/hg9DtyQmFKyFFgJbANeAVYmpprkYjT6fDz970yI1Lvr5U4qivJ455qqlL5uk6+UHd0jtu3R1HJwiDU1xZTke8742OaGMsanYuztG83AyrLf0bEptMYWGRjF3hy8HldWlJB0+INMReNp639hUkpxRWMFf3jjKFNRe/77BglgZI3eYJgFuW6K80/drMgq1SX5RKJxhieky7PIjD29IbR2bv8LU3WJl7efV8mD24/Y+g+JEBlUAzynlNqBEWx4Rmv9BPBF4AtKqQMYPS7+PfH4fwcWJbZ/AbgVQGvdATwA7AaeAv4yUZoSBT4DPI0RGHkg8VghHKV7eILf7A3w4YsW40nxNIgmXxnh6Tiv99rvpH8qGqeta5iNZygfMZknhK02zihxEjNYYIceGEqpxChV55eQmCVbTWkOYABsWVXJxFSM7Z32Hadqv7NdMSd9IWOEajrmAifLnIzSG5xkoUP7EQhn2dVjNPBMZ6OjTLlxk4//2t3P0x19vG99rdXLEcJSWusdwIaTbD+I0Q/jxO1h4IOneK2vA18/yfZfAb9KerFCWOj+V4zMvRs2Lj7DI8+deRLV1jXM+fX2+ju7o3uESDTOpqWnb+Bpqi/Lp6Ioj7bOYf4khaU285UZwLBDBgYYk0iyIQOjrXOY+rL8mcak6XTJ8kV43IoX9g5w6fLytO9vLiQDI0v4R8K2bOAJRg8MQBp5iozp8IdYVJBrmz+gyXjrygrqy/K5R5p5CiGEOAvTsTj3vXKEtzVWUl+2IOWvX1vipao4z5Z9MFoOGVeNzzYDQylFs69MJpGkSCDRMNMOGRgAlcV5M2tyKq012zuH0l4+YirMy+HiJQtt3chTAhhZoi8YpsZmI1RNNbMyMITIhA5/iLV1JbbMSDpXLpfiIxt9vHRwkDcGxqxejhBCCJv77939DIxG+OPNqRmdeiKlFE2+MlsGMF4+OEhjVdE5Zfw2N5TRNTRBYFQutCUrEAqjFJQX2iPj2ighCTu6D58/GKY/FJkZYZwJW1ZV8HrfKH1Be/6bkABGFojG4gRG7ZuBUV6YR45LzUxKESKdItEY+/pHHd//YrYPXlRPjktxr2RhCCGEOIO7WjqpK81ny6rKtO2jyVfGkaFJW530R2NxWjvPvv+FaaYkptO+o2GdIjAaMY77U9x3Za6qivOYmIoxFolavZQ5M7ODMpWBAcfGqf7WplkY9vh0iaQERiPENbbNwHC7jCY6EsAQmbC/f4xoXLPO4RNIZqss8vKutVU81NZNeDpm9XKEEELY1MGBMV48MMhHNhpTrNKlqaEUsNdJ/y5/iImpGJuWnVsAY11dMbluF+02zChxmv5QmMoi+5Tvmj0jnNzIs61zmHyPm/OqizK2z8aqIqqLvTy/L5CxfZ4LCWBkAbM0w64ZGGCszT8iJSQi/cwGntmUgQFw48YGRiameWpXn9VLEUIIYVP3busix6X40MWpb94529raEjxuZauT/paDg8DZ978w5eW4Ob++RPpgpEBgNJKRRpNny+zFEXBwI8/WzmEuXFya0awWpRRbVlXwu/1HidpwXLIEMLKAmdlQbecARmk+fQ7+5SGco8MfojAvB9/C1Dcus9KlyxexZNEC7m7ptHopQgghbCg8HePB1m6uWlud9iaKXo+btbUltuqD0XJoiGUVBXN6780NZezoCRKJSpZjMvpDEZtlYBhr6bdRqdO5mJiKsrs3lNHyEdOWxgpGw1FePWKfLCuTBDCygNlgpdamJSRgdKzuDTq7iY5whl3+IGtqi3GlMXXWCmYzz1cOD7Ovf9Tq5QghhLCZX+3sZWRimps2pad554mafGXs6A4yFbX+Cm0srnnl8BCbzjH7wtTkK2MqGqfDH0rxyuaPaCzO4HiESjtlYDi8hGRHd5BYXFsSwLhsRTlul+L5vfbrgyEBjCzgHwmT73FTnJ9j9VJOqbrEy1Q0zuD4lNVLEVksFte83ptdDTxnu765nly3S0aqCiGEeJO7W7pYVl7AJcsXZWR/zQ1lRKJx9vRaf9K/pzfEaDjKpqVze+/HenrYJ6PEaY6OTaE1tsrAKMzLoTAvh36HZoGbZU0bfKUZ33dJvocmX6ktx6lKACML9IUmqSn12npkpNlg1K7jeER2OHR0jMnpWFY18JxtUWEeV6+r5uG2bianJM1VCCGEYU9viNbOYW7c5MvY8eDMSb8NykhaDg0BnHMDT1NlkRffwgXSByMJ5kQaO/XAAKgsziPg0AyMts5hVlQWUrrAmrG0W1ZVsLMnyNExe/33kwBGFvCP2HeEqslcnzTyFOm0q8e4CrS2LjszMABu3ORjNBzliR1+q5cihBDCJu5p6SI3x8UHmuozts+aknxqSry0dVlfI99ycBDfwgVJTeRrbihje+ewlDvPkVmmYacMDICqIq8jMzC01rR2DdNkQfaF6YpGYxSz3capSgAjC/QFw1QX27f/BUBNqRHAkFGqIp06/EFyc1wsryi0eilps2npQpZXFHDPNikjEUIIAeORKP/Z3sM1F9RQVpDZK7VNvjLLyy7iif4X5zp95ERNDWUMjEboHpaLbXNhBgnsloFRXeJ1ZBPPg0fHGZmYtqT/hWlNTTHlhbm2KyORAIbDRWNxAqNhakvt9cviROUFeXjcSgIYIq129YRYXV2EJ4OjpjJNKcWNmxpo7xphtzQbE0KIee+xV/2MRaLctKkh4/ve4CulZ2TS0jGV+wNjDE9Mz7mBp6nZZ5wo2qEkxokCoxGUgvJCa8odTqWyOI/+UMRxmTVmOZOVAQyXS/HWlRX8dt8Asbh9/vtl71H+PBEYjRDX9h6hCsY/gKpiL71BiWqL9NBa0+EPsiZL+1/M9oGmOnJzXNyzTUaqCiHEfKa15u6WTs6rLrIk1bypwfqT/pZDgwBsXpZc89LG6iIKct3SB2OOAqEwiwryyLHZRaSqImOQQHBy2uqlnJO2zmFK8j0sK7c2q3hLYwXDE9Ps7Alauo7Z7PUJE+es1wEjVE21JfmSgSHSpnt4klA4yros7n9hKl2QyzXn1/Bou5/xSNTq5QghhLDIa91BOvwhbtrcYEkz97W1xeS6XZb2wWg5OERtiZf6suSOhd0uxQZfmQQw5igwGqGq2F79L+BYSYvTRqm2dhr9L1wua4c0XL6yAqXgBRuNU5UAhsOZGQ12z8AAow+GZGCIdOnwG5HhtfMgAwOMZp5jkSi/fE2aeQohxHx198udLMh1s/XCWkv2n5fjZl1dsWV9MLTWtBwy+l+kIoDT1FDGnt6QXByYg/5Q2HYNPIGZoIqTGnkGJ6bZHxiztHzEtLAglwvqS3lhX8DqpcyQAIbD9TkoA6O6xEtfMEzcRjVUInt0+EO4XYrzqousXkpGNDeU0VhVxN0t0sxTCCHmo+DENL/c4WfrhjqKvB7L1tHkK2NHT5CpaDzj+z54dJyjYxE2JVk+YmpuKCOu4bUj1k9WcRojA8N+F1SPZWA4J4DRfsQICDbZIIABxjjVV4+MMDIxZfVSAAlgOF5vMEy+x01xfo7VSzmj2pJ8pmOawXF7fPhFdtnVE2RFRSFej9vqpWSE0czTx86eIDu77VOXKIQQIjMebusmPB3nxo0+S9fR1FDGVDTO7t7MN5ZuOTgEkHQDT9OFi0tRCikjOUfRWJyjYxFbZmBUJNYUGHVOCUlb5zBul2J9vXUjVGe7orGCuIbf7T9q9VIACWA4Xm9wkpoSryV1j+eqpsQcpSplJCL1Ovwh1tZmf/+L2bZuqMPrkWaeQggx35jNOy9cXMq6OmtLJ5vM6R0WnPS3HBqkoiiPpeUFKXm9knwPqyqLaJVJJOdkcHwKraHShhkYXo+b0gUeR2VgtHYNs7qmiII8e1ygXl9fSkm+xzbjVCWA4XC9wTA1Nh+haqpJlLn4R5zzC0Q4Q2A0TGA0wlqLD+IyrSTfw7Xra3nsVT+jYWd11xZCCDF3LYeGeGNgnJs2WZt9AUaJcG2JN+OTSLTWtBwcYlOK+l+YmhrKaOsclpLnc2AGB+yYgQHGJBKnBDCisTivdo3MBAbtwO1SXL6ynBf2Ddji34UEMByudyRMdbH9+18AM4GWPsnAECnW4TfSVudbBgbAjZsamJiK8eir0sxTCCHmi7tbuij25nDNBdY07zzRhoYy2jM8ieTI0CR9oXDKykdMzQ1lhMJR3hgYS+nrZrNAYsKHHXtgAFQW5zlmCsne/lHGp2K2aOA52xWNlQyMRtjTl/lSsRNJAMPBorE4gdEwtQ7JwFhUkEuu2yWjVEXK7U4EMNbMwwDG+voS1tQUc09LF1pbHxUXQgiRXgOjEZ7a1cv1zYvJz7VH36cmXxk9I5MZvcr98qFBgJQ18DSZJ47SB+Ps9Y8mMjBsOEYVjMBKwCEZGGYplp0yMADeurIcwBZlJBLAcLDAaIS4dsYIVTCaDlaXePFLAEOk2K6eIA2LFlBsYRd2qyiluGmzjz29Idqla7oQQmS9B1uPMB3T3GiD8hFTk89oNpjJPhgtB4dYWJDLysrClL7ukkULWFiQKwGMc9AfiqAUlBfaNYCRZ5w32aD84UxaO4epLMqjvsxeGfaVxV7W1BTzwl4JYIgkmJkMNQ4JYICxVikhEak2Hxt4znbdhXUU5Lq5R0aqCiFEVovHNfe0dLF52UJWpPjEPRlra0vIzXFltA9Gy6FBNi5Jbf8LMC4MNPnKpJHnORgYDbOoIBeP256nllXFXqJxzZBNxoCeTmvXMM0NZbYc0HBFYwWtncOW912z56dMnJW+mQCGvSJ0p1Nbmi9NPEVKBSen6RqaYG3t/GrgOVthXg7XXljHEzv8BCelmacQQmSr3+4foHt4kps2NVi9lOPk5rg4v66Etgz1wegZmaR7eJKNKe5/YWpuKOPgwDhD4/Y/4bWD/lCEyiL7XlA112b3Rp6B0TBHhiZt1//CtGVVBdG45sUDg5auQwIYDmaOI3VSBkZ1idEFOOaAFC7hDLvncQPP2W7a5CM8Hec/27qtXooQQog0ubuli/LCXK5aW231Ut6kyVfKzp4gU9F42ve1bab/RfoCGADtkoVxVgKjYaps2v8CmFlbwOaNPNs6jQBgk00DGE0NZRTl5VjeB0MCGA7WGwyT73FTku+cuv/aEiOFa3DM3r9AhHN0+IMA8zoDA2BdXQnr60u4W5p5iiymlFqslHpOKbVHKdWhlPpcYvtCpdQzSqn9ia9lie1KKfX/lFIHlFI7lFJNs17ro4nH71dKfXTW9mal1M7Ec/6fsmMer5iX/COTPLunnw9dtJjcHPsdwjf5ypiKxmf+LqdTy8Ehir05nFednosXF9SXkONS0gfjLNk9A8OcjmL3DIy2rmFyc1y2vSjncbu4bEU5L+wNWHqsab/ffuKs9QYnqSnx2rJG6lSqE+Uu0shTpEqHP0RVcR4VNp09nkk3bvKxPzDGdjngEtkrCvwvrfVqYDPwl0qpNcCtwLNa65XAs4mfAd4NrEzcbgZ+AEbAA/gysAnYCHzZDHokHnPzrOddnYH3JcQZ3ffKETTwkY32ad45m3nVOBNlJC2Hhti4dCFuV3qOgb0eN2vrSiSAcRaisTiDYxFbZ2CYx4h2H6Xa2jnMBXUl5OXYY7rQyWxprMAfDHMgYN2YYQlgOFhvMOyYCSQms9yld0QaeYrU6PAH5332hel962spysuRZp4ia2mte7XWbYnvR4E9QB1wHfCzxMN+BmxNfH8d8HNteBkoVUrVAFcBz2ith7TWw8AzwNWJ+4q11i9p4/LSz2e9lhCWmY7FuW9bF1tWVbB44QKrl3NSVcVe6krz0z6JJBAKc+joeNr6X5iafWW81j3CdCz9JTFONjg+RVxDRbF9z0k8bhflhbkz417tKBKNsbM7aNvyEdOWVRWAteNUJYDhYH3BsKMaeILRxBOOTVARIhmTUzEOBMZYZ9NUu0xbkJvD+5vqeHJnL8PSeExkOaXUEmAD0AJUaa17wQhyAJWJh9UBR2Y9rTux7XTbu0+yXQhLPbsnQGA0YrvmnSfa4CtN+ySSlkNDAGxauiit+2luKCM8HWdPbyit+3E6s69Elc0zYSuLvARsXEKyqyfEVCxOk8/eAYza0nxWVRXyvIXjVCWA4VDRWJz+UNhRDTwByhZ4yMtxzTQgzZRH23u47I7fsPTWJ7nsjt/waHtPRvcv0uP1vhBxDWskA2PGjZt8TEXjXPHN5+TzLrKWUqoQeBj4vNb6dGcXJ8sv13PYfuL+b1ZKbVdKbR8YsLaZmZgf7m7ppLbEy5XnVZ75wRZq8pXRGwyn9Tiv5dAghXk5ae8T0NRQCiBlJGdg9pWotHEGBhiNPO1cQmJmLpmfOzvbsqqCbYeGmJiKWrJ/CWA41MBYhLiGmlJ7/7I4kVKKmhJvRjMwHm3v4bZHdtIzMonGGL112yM75aQuC3QkJpCsq5MMDNPrvaMoBcHJqHzeRVZSSnkwghd3a60fSWzuT5R/kPgaSGzvBhbPeno94D/D9vqTbD+O1vpHWuuLtNYXVVRUJP+mhDiNw0fH+d3+o9yw0Ze2ng+pMtMHozN9fTBaDg7R3FBGjju9pzE1JfnUleZLAOMMAqOJDAwb98AAo8TJzk08WzuH8S1cYOtmqKYtqyqZisV5+aA141QlgOFQ/hHjH6DTMjDA+IOQyQDGnU/vZXI6dty2yekYdz69N2NrEOnR4Q9Sku+hrtRZpVTpdOfTezmxMbR83kW2SEwE+Xdgj9b6n2bd9ThgThL5KPDYrO1/mphGshkIJkpMngbepZQqSzTvfBfwdOK+UaXU5sS+/nTWawlhiXu3deF2KT588eIzP9hia2qKyctxpa2MZHAswv7AWNr7X5iaGsrS3tPD6fpDYZSC8kJ7BzAqi70cHYsQtWFPE601rV3DM+N77e7ipWXke9yWlZFkPICRiRFo80Ff0AxgOO/ErabEm9Emnv5T7OtU24VzdPhDrK0tdtQknnSTz7vIcpcBfwJcqZR6NXF7D3AH8E6l1H7gnYmfAX4FHAQOAP8G/AWA1noIuB14JXH7amIbwKeBHyee8wbw60y8MSFOJhKN8cD2I7xzddXMKEg7y81xcUF9SdoCGK8cNv6Zbl6WmQBGs68UfzAsf0NPIzAaYVFBLp40Z8Qkq6o4j7g2mo7aTffwJAOjEds38DTl5bi5dPkiyxp55liwT3MEWptSqghoVUo9A/wZxgi0O5RSt2KMQPsix49A24Qx3mzTrBFoF2HUp7YqpR5PdBPPemZtoSMzMEq99I9GiMV1RlIhK09R81YrV+0dbToW5/W+Uf7s0iVWL8VWakvz6TnJgZZ83kU20Fr/npP3qQB4+0ker4G/PMVr/QT4yUm2bwfWJbFMIVLmqV19DE9Mc9Nme45OPZkmXxk/ffEwkWgs5eMgXz44hNfj4vy6zPQJaG4wAiVtXcPyd/QUAqEwFQ4oe6hKrLE/FLZdMNAM+DXbvIHnbFsaK3j29QCHj46zpLwgo/vOeKgs3SPQMvhWLNUbDOP1uCjJ91i9lHNWU5JPLK4ZGE1/I52RiSn0ifn0gNuluOWqxrTvX6TPgcAYU9F42pt4Oc0tVzWS7zn+gDHX7ZLPuxBCONBdL3eyZNECLltebvVSztoGXxlTsTi7elI/vaPlkNH/IjcnM6cw59UUke9xSx+M0+gfDdu+/wUwE7SwYyPP1s5hCnLdNFYXWb2Us3bFKqOh8PN7A2d4ZOpZmuuTphFo80JfMExtSb4jU+fNrBF/mieRhKdjfOJn2xmZiPKZty2nrjQfBRTkuonFNSsqC9O6f5FeZgPPtTKB5DhbN9TxD390/sznPcelyM1RXL7SOQe/QgghYG/fKK8cHubGTT5cNm/eOZs5RaE9xWUkwYlpXu8LsXFJesenzuZxu1i/uET6YJxGIBSh0uYjVOFYk1E7NvJs7Rxmg6/M9k16Z/MtWsDS8gJLykgsC2CkcQTayfaVdePO/MFJqh1YPgLH+nb0pbGRZyyu+fx9r9LaNcw/fXg9f33Vebx465UcuuO9/OHWt7OoIJcvPbaLePykHxnhALt6guR73CzNcNqaE2zdUDfzeX/is29hKqq59ZGdJ81GcpTeXtiyBfr6rF6JEEKk3T0tneS6XVzfbP/mnbNVFnmpL8tPeR+MVw4PoTVsylD/C1NzQxkd/hCTU7EzP3ieicU1R8citivJOJlFhXm4lFHyYifjkSh7ekM0+ew/PvVEW1ZV8NLBQcLTmf23YUkAI80j0N4kG8ed9QXDjmzgCVCbGP2aroZIWmu++ssOnuro42/fu4ZrLqg97v6SBR5ue89q2rtGeLD1yCleRdjdbn+INbXFjopWW+G86mL+5upGntndzwPbHf55/7u/g9/9Dr70JatXIoQQaTUxFeWRth7ec341CwtyrV7OOWvylaV8lGrLoUFyc1xcuDizJ3rNDWVE45od3ekbDetUg2MR4tqY8GF3bpeioujkffGs9NqREeIaxzTwnC03RxGejnPel57isjt+w6PtPRnZrxVTSNI6Ai0jb8Ji0Vic/lDYkQ08AUryPXg9rrSNUv3hbw/ys5c6+cRblvLxtyw96WM+0FTHxUvKuOPXrzNsw27EtmWTK+DxuGZ3b0j6X5yl/3HZUi5dvoiv/HI3h4+OW72cc6c1fO978OMfG9///OfGZ/Cll+D66+GLX4Qf/QiefRYOH4aYXCUTQjjbL1/zMxqJctPmBquXMidNvlL6Qqmd3tFyaIgLF5fi9aS2MeiZbFhsnFi2pmmyipOZwQAnlJCA0Qejf9ReGRhmf5UNDmrgCfBoew8/f6lz5ueekUlue2RnRoIYVmRgZGIEWlYbSEQ7nVpCopSitiQ/LSUkj73awx2/fp1rLqjhf79n9WnXcPvWdYTCUf7x6b0pX0fWuv12+P3vja/pdIZASefQBGORqAQwzpLLpfjWh9aT41L81QOv2nIG+im1t8Nb3wqf+QzM7vlz++0wOAi7dsF3vgN//ufwjnfA0qWwc6fxmKefhv/5P437f/lL2L0bwmf5e8cmwTohxPx018tdNFYVcZEDr8rCsavJqSojGYtE2dUTZNPSzJaPAJQV5LK8okD6YJxEIBEMcEIJCRjlTXbLwGjtGmZVVaHjBjPc+fRewtPHH09OTse4MwPnVRkfo5qJEWjZzsxcMEsxnKim1JvyJp4vHjjKXz/4GpuXLeRbH1p/xoZX51UX82eXLuEnLx7iwxcvznhKouP09sJPfgLxuHEl/MILobIScnONE70FC8DvN265ueDxHPtaVwduN0QixhV0j8f4+VRmB0q+97033d3hDwLSwPNc1JTk87X3n89n723ne8+9wefesdLqJZ2Z1vCpT8GBA8ZnZnra2D41BT/9qVFK8vrrRsZFTw+88YZxW5l4b6+/bmRrhGa1WVIKjh6FhQvhscegowOWLz92K0ucLJzhMyiEEOmyo3uEnT1BvnrdWkc2awdYXVOM1+OirXPkTaW8c7H98BBxDZuWZq6B52zNDWU8s7sfrbVj/5+kg/MyMPJS3lw2GfG4pr1rhPecX231Us7ZqbKr0tUiYDZLp5CIuekdMQIY1cXO7IEBxtrN95EKu/0hPvWLVpaVF/LDP7norOeOf/4dK6kozONvH91JTBp6nt7tt0M0anw/NQU33wxbt8J73gNmc9yf/AQuvhjWr4c1a2DFCmhogJFE3eiXvwz5+ZCTYwQwvLuaknUAACAASURBVF4oKjJeD4weBw0N8K//agRK/u3fjCvsJ9jVE8LjVqyqcs64KTu4dn0tWy+s5f/9Zj+vHrFpLW80Cj/4gZFdoRTcdZfxOTvxgDEWO5YJ5HaDzwdvext84hNQkGjs+rnPGZ+9QMAoN7nrLvja144FKZ56Cv7P/4EbbjA+twsXQn29EYT76U+PBev27cvc+xdCzHt3v9xFvsfN1g3OHa7ncbu4oK40ZRkYLYeGyHGpmQknmdbcUMbwxDSHnFiGmUZmBkaFYwIYXgbHp5iK2iMT9eDRMYKT0zQ5rHwEoLb05Oehp9qeShnPwBDJ601kLjg5A6O21EtgNEw0FifHnVwcrWdkko/9xzYK8nL46ccuPqcUrCKvh7+9Zg2fvbede1o6+ZNLliS1lqzV22uc0M3uLZCXB48/DsXFUJ2IHH/4w0bwYmrKuFo+PW18X5QINLz73cbJo3m/+dWT+H+2YoXxukoZV9+np2HzZuMKustlbFOKDn+QVVVFGZsDn02+ct06th0a4q/uf5UnP/sWFuTa6M/Ac8/BZz9rBK2mpowAxMqV0NZ2LMhlmpqCP/zhzK+pFFRUGLfNm4+/7wc/gDvvhIMHj2VvjI8bQY54/Nh+Ghth9WrYtAne+U648cbUvF8hhDhBcHKax1/zc92FtRR7nZVSfqINDaX85PeHCE/Hku5b0XJwkAvqSyz7m9WcKIlp7RxmWUWhJWuwo/5QhEUFuXiSPJbPFHOU6sBYhLoMnGifidn/otmBpWK3XNXIbY/sZHLWBJJ8j5tbrmpM+75tdOQqzlZvMIzX43JcrdRs1SVe4hoCo5GkInXBiWk++pNtTERiPPjpS+b0Wu+7oIb7tnVx59N7eff5NZQXOiOKnFG3337shM6ktZGCPzu9fuXKY+n7J7Nli3E7lXe+0+hlMHtf09PGFfTKSrj4YvRllxGNrmbt2y6Z23uZ50ryPXzrQxdy449f5mtP7uHv33++1UuCzk7467+Ghx6CJUvgkUeMrAtTe3v69l1YCBdcYNzACNYtW3Z8wCQnxyiDeuIJGB4+FsC48UZYvNgIjGzaBLXJp0mnXW+vkXFy//3HAo9CCNt4tL2HyekYN21yZvPO2Zp8ZfwwdpAOf5Dmhrn3rpicirGjO8gn37oshas7N8vKjR4FbV3DfPAiZ421TaeB0bAjJpCYzLX2h8K2CWCULfCwtLzA6qWcMzND7M6n9+IfmaS2NJ9brmrMSOaYM8Jl4jjmCFUn1+DVJkbA9ibRByM8HeOTP99O1+AEP/zTZs6rnltDR6UUX71uHZPTMf7hV6/PeT1Z7aWX5n4F/FycLFBibg8GjQyNH/6Qe3/wF9z6vz8C3/72sfIVJ7BJY8hLli/i5suXcU9LF8/u6bd0LYAxReTJJ+GrXzUabb7//W8uGcmUk30GXS5YtcoIpP3iF8a2SMTI2Pj2t+GP/sgIcPh8RvkTGK8xmf460LOmtbGeTDXiFUKcM601d73cyfr6Es6vd36PJzMtPtlxqm1dw0Tjmo0WNPA0uVyKJl/pzBVzYegPRRzT/wKgqsgIYARC9phE0to5TJOvzLHndFs31PHirVdy6I738uKtV2as7E0CGA7UG5x07AhVU02i/GWuo1Tjcc0XHniVbYeH+OaH1nPp8vKk1rOispBPXL6Mh9u6eeXwvBhmc27a240ToBNvqb4yfrpASVkZ3H8/Lzz3Gn/7zk+TV5APX/gCbNtmPC4UevNz7URruPVW25w8fuFdq1hdU8wXH97B0bEMd+TWGh5+GPYmOlV/85tGw80vfcnokWKl030GlTpWDpWXBy0txufuD38wAhmXXQblid9F+/YZ5VUXXWRMUPnFL2D/fuO9n2iuga143GhI2tFhlN/8+tfH7rvjDnjf+2DjRqOvzIIFRqaI2dvjpz+1PJAmhDjeK4eH2R8Yy4rsCzD6IixemJ90H4yWg4O4FJZPZGluKGNfv9GzQBj6Q+GZsgwnMNdqh0kkw+NTvDEwPjOxR5w9CWA4UG8w7NgRqqaaRAPSuTTy1Fpz+5O7+dXOPv7Pe1Zz7frUpG3/zytXUFeaz5ce3eWsMZPZ5CwCJa9OuLi7+b3Qss3olXDVVcYd3/iGcRX885+HV1+16A3MYl7Fb2+Ha64xSmB+/vNjzUkPH7Z0eXk5bv75hgsJhaPc+vAO9MlOrNNh1y5j3On118N3v2tsq683shfs4FyDdV4vXHKJ8bm7917jfYERMPibv4GSEvjZz+BP/9TI4vjlL437Dx82xrwOD588K+LwYfiv/zICH9/8JtxyC3z608fu/+QnjSBKRQWsWwdXXgkf+9ix+w8cgO5uozHpFVcY42TLyo59Lmc3QRVC2MLdLZ0UeXO4Zn2N1UtJmSZfGW1dw0n9jXn50BDr6koosrgniHmiaacpFlaKxTVHxyJUFjnnnKRsQS4et6LfBhkY7Uec2//CatIDw2GisbjRN6LE+rqtZBTn57Ag1z2nUao//t0hfvriYf7HZUv5xOVLU7amBbk5fOmaNXzqrlb+4w+H+cTl1tVailPr8IdYVl5AQV4OrF177I53vMO4wv2DH8A//7PRTPTP//z4k7506euD1lbYvt24tbbCP/wDfPSjRoPSzk5YtMg4WY3FjL4eX/6ycWJroVVVRdx69Xl89Ynd3LvtCDduSmMQYXgY/u//NXqmFBcbX2++OX37s5rPB1//uvF9LAZ79sDLLxtZGgAPPmgEOOBY09rvf9/oBbJ0KXznO8bn2JSXZ/SsiMWMqStXXGEEL6qqjt1m97T48Y+PX8+JvT1mj6KVXhhCWG5wLMKvd/Zx4yafvZorJ6nJV8Zjr/rxB+fWcyA8HePVIyN89BLrs1LW15fidinaOoe5orHS6uVYbnAsQlzjqAwMl0tRWeS1RQZGa+cwbpdifb01k3WcTDIwHGZgLEIsrh2fgaGUoqbES985lpA8/pqfr/9qD+89v4a/fe/qlNeMXbW2iisaK/jOf++3RXRWvFlHT5C1tSepDX7b2+CBB4wTte99D3Jz4fnnj93/3HNG4CBZgYCRqm/2/xgYgJoaI8viK18x+iK84x1G2j4YV8f/67+MIMbsKS4PPmis9WMfg7vvPv6+DPqzS5fwlhXl3P7E7vSOh/vWt+Bf/sUIKu3fD3/xF0ZzzPnA7TY+B5/4hBHIAvjUp+DZZ43mnyaX61jQ49Ofht/9ziizGRkx+lccPmy8FsBNN8Hf/70xqeWGG4zP/+rVp17DyXp7SBaGELbxYGs3U7F4egPJFjjWB2NuWQuvHRlhKhpn49JFqVzWnBTk5bC6pohWycAAjEb8gKOaeAJUFufNjH+1UlvnCGtri8nPTW5Cz3wkAQyHMXtGOL0HBkBNST7+cwhg/OGNo/yvB15l49KFfOtD63G5Ut/wRinFV65dy1Qsztee3JPy1xfJGR6fwh8Ms7b2NA1bFy40To63bTuW4fD660aKfV0d/NVfwf9n777Do6rSB45/3/Te6AmEUIP0DgoqKyqKqyIWdHXXsta17K7KWta24iquuu7603VtiAW7gAUEZRVQqgSkFxEIpEAgIYWQnvP7484kk96n5f08T56Ee2fmnjMzzJz73ve8Z/Pmyts3pv7As89ahRp79rSudE+datU8AOsq+Msvw8qVVqHRHTusqSKTJlXev66Tx4cesqYmXHONlTGyYEHtNRLakI+P8Ozlwwjw8+FPH/5ESWtOn1q1yqopAVa2QVKSFVzq4PqBqMuFh1sBh82bK1/z8nJ47z3rvZiYCBMnWtNOIiNbXtTUWYV4lVJNVl5ueG/dQcb2iqF/l3BXN6dVDegWTpC/T7PrYKzbn4UIjE1wXQFPR6Pio/npYLZONYaKC32eVMQTrEKerr5IWVpWzk+HsisCfKppNIDhYQ5XBDA8ewoJYMvAaNwUkl2Hc7nl7SQSOoTy2m9Ht3g98fr07BDKbWf24YvNaazae6zNjqOabntaLgCD4xpZnT3IFujr29daAvPMM600/eHDYcQIqx6Dvf7AQw/BsmVWLY3LL69cKhOszI5t26z0/2eftTI73nijcv+tt8Lpp1cWeKyurpPHjRutnw8/tLJDpk+3rsj/8kvj+tdKukYG8eQlQ9h8KJsXv93b8gdMTbWCMhMnWtNGwJo2Mnx4yx/bmzgzK8JZhXiVUk32w95jHMw6ydVeln0B4O/rw9DuUWw82LyVSNbtz2RA1wgiQ1xb/8JuZM9o8ovL2H0kz9VNcTl7BkYXD8vA6BIR6PIpJLsO51FQUqb1L5pJAxgeJi3bOuH3igyMqGAy8ooavOKbll3AdXN+JCTQl7k3jHXKl9htk/oQHxPCI59to7hUo+zuYltaDkD9GRi18fODCy6wpm2kpVlTGUJCrO32VRneeAPOOcdaKWTjxqqrYfzwg7WqxHvvwT33WIGQiCa0ob6TRx8fuOIKayWJOXOsK+32mgTZLVt6rikuGNqN6SPiePG7vU27UuaYwVJUZK1+kZgIn3xiBYXmz2+7Rns6zYpQSmEV74wJDeC8wd5Zj2ZkfDTbU3MoLGnaVMni0nKSko8zzoXLp1ZnP+Fs7pQYb2LPYugY5lkZGJ0jgsgpKGny+7E12Zfj1QBG82gAw8MczikkyN+HKDeJRLdEt8ggjKHeNK6cghKue3M9+UWlzL1+bLMKQDVHkL8vf7toEL8czef1H/Y55ZiqYdvTcomLCiYqJKD5D9KhA9x+uzW94YUXKq+A+/pay05mZloZEI4ZFgEtOF5j+flZ9TDWrYPQUCsjY+xYa7rKxo1tf3zgsYsH0TUiiD9/+BP5RaWNu5PjChrvvQcPPGAFgnbssLaFhrZtoz2ZZkUo1e4dzilk2c4MLh/dnUA/75wLPzI+itJyw9bUnCbdb2tqDoUl5W4VwIiLCqZLRGDFCWh7lpFXRIfQAAL8POt00p4xkuHCLIyk5ON0iwwi1knnNd7Gs95xivScQrpFBrd68UpXsGeR1FXIs6i0jJvf3sD+Y/m88ttRnNKtiVfdW+hXAzpz7sAu/N//9pKa3fTVUlTrswp4ttL7ID3dyr6wXwEvK7OmkFS/Iu4q5eVW0ce1a2HUKGtay862rcsSEeTP8zOGczDrJE8s2lH/jY2xgi2vv2619c03rcDF8uVWLY/euoqPUko15IMfD1JWbvjNWO+bPmI3splZC+v2ZwIw1o0CGCLCqJ7RWsgTyMgtpJOH1b+AylVTjriwkGdS8nGtf9ECGsDwMOk5BV4xfQSoiDrWVsizvNxw90ebWbc/i2cvH8ZpfTs6u3kAPHLhQAyGWV80cDKn2lx+USn7M/MbX/+iIe6+KkNgoFX4cv9+eOQRWLLEWsnCXhSzjYztFcOtZ/bh/fWH+GbHkZo3eO89a9WL7t1h/PjKlV3KyqylY888s03bp5RS3qK0rJwP1h/ijP6d6NnBe7PVOoYFEh8T0uRCnuv2ZdGvcxgd3GyKwsj4aA5lFZDRzlery8gr8rj6F1CZgeGqQp6HcwpJzS6oCOypptMAhodJzyn0+CVU7ez9SK8lu+HJxTtZtCWdB84fwMXD45zdtArdo0O486x+LNl+mOW7M1zWDgU703Mxphn1L+riKfUHIiOt5Vn37bOWzbQvu/n111Y9jzbw57P7M6xzEO//8z1O/G2WVZDTvlLG4sXWlJExY8DfYSpbcbGVhVHfai5KKaUqfLsrg8O5hV5ZvLO6UT2j2XgwG9PIlbZKy2z1L3q7T/aFXUUdjHaehXEkt9DjViABaxUSwGWFPO3vG61/0XwawPAgpWXlZOQVeU0GRkSQP2GBfhVLw9q9/v0+Xv9hP9edlsDNZ7g+Df2m03vTu1Moj36+3aUFf9q7ban2Ap6tlIHhafUHOnWC++6zin4WF8Nvfwt9+sDMmXCsFVfL+eILAs6axIIHL2DOG3cT9tgjmI0bKwuKvvYaHDoEsbE1l/Z0pwwWpZRyc/PWHaRLRCCTB3R2dVPa3Mj4KI7mFZFyvHFTcnek53KiqJSxvdxv2e1BsZEE+Pm06zoYZeWGYyeKPTIDIyLYj0A/H5dl0CQlHyfQz4eBTp4a7000gOFBjp0opqzceMUSqnbdIoNId1hK9cstaTyxaCfnDerKw78e6Ba1PgL8fHj8osEkZ57klRVa0NNVtqfl0jEsoGLuYrsWEGBlkFx+OTz3nFVv4tFHIacJBdLS063lYe+6y1pS1h64KS6GoiJ87riDb5/8LyPvnMe8OV9BtO1KQXCwFbjwlAwWpZRyQwczT7Ly56NcOSYeP1/vH46PiG9a1sK6fVkAjHej+hd2AX4+DOse2a4DGJn5RZSVGzp74JhMROgSEeSyKSQbDx5nWPcojyt+6k70mfMgaTnes4SqXdfIoIoMjLX7Mrn7w82M7hnNv64cjq+P64MXdhP7deSCod34z/K9HMw86ermtEvb0nIZGBvpFkEtt9C7N7z9NmzbBueeC48/bv1t57i8qTHWEqdgLdfap4+VQTFjhrXaSocOlcGISy+1inM++yyT7ruZQcP68MSiHfxy9ETV43taBotSSrmR99YfxEeEq7y4eKejAV3DCQnwZdPBxi0Pvm5/Jr06htLZTa/wj+wZzbbU3HabmWtfwaNzuHu+Pg3pEhHokikkhSVlbEvN0foXLaQBDA9iX63DWzIwFm5KJSn5OFtSchj792VcO2cdPWKCef3a0QT5u99SYg9fMBA/H+GxL7Y3eg6nah1FpWX8fCSPwa1V/8KbDBwIn3wCe/bAhAnWtkcesbIzvv8eTjsNuna1CmwCxMfDsGFW5sb69dbUkGXLKmtrOPDxEZ69fBhB/r78+cOfKCkrr3EbpZxJROaISIaIbHPYFiMi34jIz7bf0bbtIiIviMheEdkiIiMd7nOt7fY/i8i1DttHichW231eEI2YtoqFm1KZMPtbet2/iAmzv2XhplRXN8mlikrL+HjDISYP6Ow1dc0a4ufrw9DukY3KwCgrN6zfn+VWy6dWNyo+muKycranNW1pWG+RYVvBw1OzYjtHBLlkFZJtqTmUlBmtf9FCGsDwIGnZ3pOBsXBTKg/M38rJYitynZFXRFGp4epx8USFBLi4dbXrGhnEn87uz7e7MmpfnUG1mZ+PnKC03LRe/Qtv1K+f9busDL77DlatsjIiDhyAM86AsWOt/eHhMH8+3H13zUKctegSEcRTlwxhS0oOL/zv57btg1INmwucV23b/cD/jDH9gP/Z/g1wPtDP9nMz8DJYAQ/gUWAcMBZ41B70sN3mZof7VT+WaiL7931qdgEGSM0u4IH5W9t1EGPp9iNk5hdz9fierm6KU42Mj2ZHWsNZC7sP55FbWOpWy6dWZ7+C3l6nkdizF9w1Q6YhXcKDKrJInMn+fhkZH+X0Y3sTDWB4iIWbUvnXsj0A/Pr/vvf4L/5nlu6moJYvsDd+OOD8xjTBdRMS6N8ljL99sYOC4vaZNugKlQU8NQOjQb6+1nKr9sCEvz907gxTpzb7Ic8f0o3LRnXnpe/2kpSc1UoNVarpjDErgepvwouBt2x/vwVMc9j+trGsBaJEpBswBfjGGJNljDkOfAOcZ9sXYYxZY6w0u7cdHks1U23f9wUlZTyzdLeLWuR689Ym0yMmmNNdtES8q4yMj6a03LAlpf6shXX7MwEY19v9CnjadQwLJKFDSLsNYNhP/ju52RK3jdUlIpATRaWcKCp12jEXbkrl+W+sc7mLXlzl8edyrqQBDA9gv3pxosgaAKRmF3r81Yu0WpZOrW+7u/D39WHWxYNJzS7gxe/0arSzbE/LJTzQj/iYEFc3xf2lp8PcuVBSYv27lZY3ffTCgcRGBfPnDzc79QtfqUboYoxJB7D9ti/pEAcccrhdim1bfdtTatmuWsBTv+/bys9H8li3P4vfjO2JjxvV+nKGEbarzg1NI1m3L4vu0cHERbn3lOmRPaNJSm780rDe5EheITGhAR5biNK+eoqzViKxzuW2UFhqTcXVTLSW8cx3XTvjjVcvYuv4UqpruzsZ17sD00fE8erKfTULG6o2sS0th1NiI9rdYK9ZZs2C8mq1KlphedPwIH+enzGclOMnefyL7S16LKWcpLYPDNOM7TUfWORmEdkgIhuOHj3agiZ6v9io2lPMI4L9KG2HdXXmrTuIv69wxejurm6K03WwZS1srCdrwRjD+gNZjHPD5VOrG9UzmmMnijiU1f6CcRm5RXQO98zsC6Bi9RRnFfJ8ZukuCkqqft55+rmcK2kAwwN449WLmVMSCa5WqDPY35eZUxJd1KKmeWDqKQT5+/LoZ1rQs62VlRt2pecxWOtfNE4bLm86JiGG2yb14aMNKSzZ1rKMDqVa0RHb9A9svzNs21OAHg636w6kNbC9ey3bazDGvGqMGW2MGd2pU6dW6YS3Gta95lxvH4GcglIufHFVu0rBLygu49ONKZw/uBsdPDT1vqVGxkez8WDdWQt7M06QlV/MuN7uW//Czl6IMelg+5tamZFX6LH1L8AhA8MJhTxLyspJza79OJ58LudKGsBwYzkFJTz62bbaL//gGdkKdZk2Io6npg8hLioYAeKignlq+hCmjfCMbN1O4YHce24iP+w9xqKt6a5ujlfbf+wEBSVlWv+isdp4edM/Tu7P4LgIHpi/xWmpl0o14HPAvpLItcBnDtt/Z1uNZDyQY5tishQ4V0SibcU7zwWW2vblich42+ojv3N4LNUMCzelsnjbYUb3jCIuKqji+/65y4fx32tGkn2ymEtfXs0D87eQfbK4wcfzdF9sSSOvsJSrx7WPpVNrM8KWtZByvPYTt7X7rWCAO69AYtevczjhgX7tKghnl5FbRBcPzsCwBzCOtPE4JqeghOveXF/nfk8+l3MlP1c3QNVUXm6YvymV2V/tJDO/mAl9OpB08DiFDqlHnpStUJdpI+I8JmBRm2vG9+SjDYeY9eUOJiV2JixQ/zu1hW2puQAMitMAhjsI8PPhXzNG8Ov/+56Zn2xh7vVj0JUmlbOIyPvAJKCjiKRgrSYyG/hIRH4PHAQut918MTAV2AucBK4HMMZkicgs4Efb7R43xtgvod6GtdJJMPCV7Uc1w9p9mfzlky2M7x3D2zeMq3Wu/MR+nfj3sj3MWXWApduP8MD5A7hsVHev/UyZt+4gfTuHufXqGm1tpEMdjB611LVaty+TrhFBHlHzytdHGB4fRVJytqub4lRl5YajJ4oqpmF4orBAP0IDfNt0CsmhrJNcP/dHkjPzuWpsDxZuSqtSEsAbzuVcRTMw3MyOtFyueGUN9368me7RIXx++0Tm3TSe2dOHemy2grfy9RFmTRvMkdwi/m1bIUa1vu1pOQT6+dC3U5irm6Js+nYO48Gpp7Biz1GGP/4Nve5fxITZ32oxKtXmjDFXGWO6GWP8jTHdjTFvGGMyjTGTjTH9bL+zbLc1xpjbjTF9jDFDjDEbHB5njjGmr+3nTYftG4wxg233ucPoHMFm2ZtxglveSaJHTDCvXDO6zkJ/YYF+/PWCgXx550R6dQxl5idbmPHKWvYcyXNyi9vettQcNh/K5upx8V4boGmMxC7hhAT41loHwxjDuv1ZjOsd4zHP0aie0ew+nEteYYmrm+I0WfnFlJWbiiwGT9UlIqjNMjA2HTzOJf9ZRUZuIW/fMI6npg/16Mxzd6OXjN1ETkEJz3+zh7fXHCAy2J+nLx3C5aN6VBQt9PRsBW81Mj6aK8f0YM6qA1w2qgeJXcNd3SSvsy01lwFdw/Hz1XirOwkP9LPNY7cGbfaK2oB+VinVjh07UcT1c9fj7yvMvX4skSH+Dd7nlG4RfHzLqXycdIinvtrF1H9/z+9P78UfJ/cjJMA7hqrz1iUT5O/D9JHtr3inIz9fH4Z1j2LjwZpZCwcyT3I0r8gjCnjajYyPptzA5kM5TOzXPpbFtZ/0e3IRT7AKeWa0QQbG4q3p/PnDn+gSEcQHN4+hb2frApyey7UePSNwMWMMnyalMPm55by15gC/GRfPd/dOYsaYeF1xwUP85bwBhAf58fBn27SgZyszxrA9LYdBcVrA0908+/Ueyqu93bWitlLtW0FxGTe+tYGjeUW8fu2YWqcI1MXHR5gxJp5v75nE9JFxvLJiH+f8cyVfb/f8gsG5hSV89lMaFw2LJTK44YCOtxvZM4qd6bkUFFddYW/dvkwAj5piMzw+ChHaVR0Me+FLTy7iCbYMjFYs4mmM4b8rfuEP8zYyKDaCBX84rSJ4oVqXBjBcaGe6NV3kHofpIk9MG0JUSICrm6aaICY0gPvOG8D6/Vks0BT6VpVyvIDcwlIt4OmGvHF1JKVU85WVG/704SY2p2Tz7ytHMLxHzdVHGiMmNIB/XDaMj289lbBAP25+J4kb3/qRQ1knW7nFzvPZplROFpdx9bierm6KWxgZH01puWFLStUsjHX7s+gYFkifTqEualnTRQT5k9glnKSD7SiAYcta8PQMDPsUkta4+FhSVs6DC7Yy+6td/HpoN967aXy7XWnIGTSA4QK5hSX87Yvt/Pr/fmBvxgmevnQI8287jSHd9Sqzp5oxugfDe0Tx5OKdFSn1quW2p+UAMEiXUHU7dVXO7ujhAxqlVPM8uXgnS7cf4eELBjJlUNcWP96YhBi+vGsiD04dwOpfMjnn+RX8Z/leikvLG76zGzHG8O7agwyOi2CojvMAGBFvLT/qOI3EGMO6fZmM6+U59S/sRvaMZlPyccqrpyV6KXvhy04e/n3fOTyQwpJycgtLW/Q4uYUl3DD3R95ff4jbf9WHF64cQZC/byu1UtVGAxhOZIxh/sYUznp2BXNXH+DKMT10uoiX8PERnpg2mKz8Yv75tabQt5btabn4+ggDtLaI25k5JZHgal/QAmSdKOLzzWmuaZRSyiXmrtrPGz/s57rTErhhYq9We1x/Xx9uPqMPy+4+kzP7d+IfS3Yz9YXvWWubauAJkpKPs/tIibYfTgAAIABJREFUHleP6+lxJ+ZtJSY0gF4dQ9nokLWQcryAtJxCxvX2nOkjdqPio8krKuXnjBOubopTZOQVEhMaQKCfZ5+k24uQtmRJ+ENZJ7ns5dWs+SWTf1w2lJlTBug5nRN4R2UkD7AzPZdHPtvGjweOM6x7JHOuG83Q7s1Lr1TuaXBcJNeM78lba5JZvO0wx/KKiI0KZuaURC3a00zbUnPo2ylMI9luyP6efmbpbtKyC4iNCua2Sb35/Kd07np/E3sO53H3Of31i1wpL/fNjiM8/uUOzj6lCw//emCbHCM2KphXfjuab3cd4ZHPtnPlq2uZPjKOB6eeQkc3T9Oet+4g4YF+XDQs1tVNcSsj4qNYuecoxhhEhHX7rZWMPan+hd2onlZGSVLy8XZRzP1IbpHHTx+BygDGkdwi+nVp+uv206FsbnxrA0WlZbx9w1hO69s+iri6Aw1gtLHcQvvqIslEBPnx1PQhzBjdQwf1XmpAN+sD8GielV6nKzO0zPa03HZT1dsT1VZR+4rR8Tzy2TZe/G4ve47k8fyM4YQG6leNUt5oS0o2d72/icFxkbxw1XB823hsc9aALpzauyMvfvczr67cx7IdR7jv/AFc5aaZrFn5xSzams6VY3ro52A1I+Ojmb8xlUNZBcR3CGHdvkyiQvzp39nzAgA9O4TQITSApOTj/GZcvKub0+aO5hV6fAFPgC4RVhCmOUupLtmWzp8+/ImOYYF8cPM4+nrg+9aT6RSSNmKMYcGmyukiM8b04Nt7JnHVWPf8klWt46Vvf6mxTVdmaJ6MvEIy8oq0/oWHCfDz4anpQ3j0woEs23mES19e7dHF95RStUs5fpIb5m6gQ1gAb1w7xmnLnQYH+DJzygC++uPpDIyN4K8LtnHJy6vZlprjlOM3xadJKRSXlreLk9qmGmmrg5F00Mq8WLc/i7EJMR45RhYRRvaMrjIlxiulp8OZZ1KSmt72GRi2Y3G47VYh6hxuy8BowkokxhheXfkLt83byCndIlh4+wQNXriABjDawK7Ducx4ZS1//nAzcVFBfHb7BJ68ZAjRobq6iLfTlRlaz/a0XAAG6wokHkdEuH5CL+ZeP5bU7AIufmkV623pwUopz5dTUML1b/5IcWkZc68f45Jifn07h/P+TeN5fsYwUo+f5KIXf+Cxz7fzwfpkJsz+ll73L2LC7G9Z6KLVwcrLDfPWJTO6ZzQDuur3WHWJXcMJDfBlz6afKZpwOgUHUxnXu0PbHrQNT4pH9Yxm/7F8Mk8UtfmxanDWsWbNwvzwA1d9/VZF9kJbHosffrB+t5HgAF8igvw4eSClUc9fSVk5f124jScX72Lq4G68f9P4pk9hc9Zr5Y3vPweaz9YCCzelVpn/fedZffg5I5+5qw8QrtNF2qXYqGBSawlWiMBL3+3l6nHxukxuI+2wBTAGagDDY53RvxMLb5/ATW9t4OrX1/LEtMHMGKNXIpXyZMWl5dz2bhIHMvN564axLr36KCJcMqI7ZyV24ZmvdzF39YEq+105jXP1L5kcyDzJH8/u59TjegpfH2FYjygGz5lNwJpV3FkQwcgHLmzbgzqeFL/0Uus8pjFQXMzoLkEEFxeyeWcKZ/XrAI8+ah3rb3+Dv/+95v1CQyEwEEpKIC+v5v6wMAgIgOJiOFFLcdDwcPD3t/b/9a/Wse6/H558EsrKoHNn6/Fzc60Ty7IyKC+v/J2YCMHB1snn/v1V95WXw4QJEBQEP/8Mu3bBsWPwxhtIeTkzflrKZ/kPWO3YuhX27KnZvksuAR8f2LQJ9u2rus/Hx9oP8OOPcPBg1f0nTsCbb1rteOMN6+S4a1fr+QgMtJ67/v2t2x4/br0GAQHWj7+/NehupC4RQYx558UG3xe5hSXcPm8j3/98jD9M6sO95yY27/yurd6DZWVQWmr9BARUHueBB2D27Kq3j4iwXvviYuv5qy4y0nrti4ogO7vm/uho6xiFhZCTYx2jtfvUAGmNtW89yejRo82GDRta/DgLN6XywPytFJSU1dh31dh4/jIlUTMu2qHa3hcBvj706hjC7iMnCPb35YrR3blhYi96dvCcdc5d4bZ3k9iRnsuKmb9ydVNUC+WcLOGO960v/usnJPDXqafg56sJgN5ERJKMMaNd3Q5XaK1xhScwxnDvx1v4dGMK/7xiGNNHdnd1k6oY88QyjtqvgDuIiwpm1f1nObUtt72bxNp9max5YLIWoq7Dy+99z/XXnk1QaTHlCNK3D+Jnu7Y6YQK8/rr19+TJkFZtdatzz4V//9v6e/x460TK0SWXWCfzAEOHQkEB/PKLdbInAvfcA888Y52E9e1b8wT+z3+Ghx6Co0ehZ8/K7fafJ5+0Agb79kGfPjU75+9vBScCA60TwermzoVrr4VVq2DixJr7P/0Upk+HJUvg/PNr7v/6azjnHHjtNbj55pr716yxnpc5c+D3v6+5f9s2GDTIeg7/9Kea+5OTIT4enngCHn64xu6US66k+/z3refg6adr3r+42HoObr8d/vOfqvsCA63nHazn4O23a+63BYYQsf521KtXZVDknHNg2bKq+0eMgI0brb9//WsryBIYWBnkGD0aXn0VgJWnTWXi2qX4mHLw9YXzzoNTT7WCQgC33ELB4Qw2HDhOflEpg+Ii6HHB2XD33db+3/0OTlabJnvWWfCHP1h/X3GF9X4B6z24ZIn17+Bg2L4dbrqpMvBg//n97+G226z33qmn1tz/6KNw551WcOmUU6z3raPZs+Gxxyqf4+reeQeuuQZWrrSCQ9UtXAgXXwyLFlnPX3X/+5/Vxw8+gKuuqtweHGy9Ll1bvoy2XV1jC83AaKZnlu6uNXjRKSyQp6YPcUGLlDuobWUG+yokO9Nzef37/by3/iDvrE1myqCu3Hh674rq1cpiz2xKzS4g2N+HhZtStQCqh4sM8efN68bw5OJdzFm1n70ZJ3jxNyOJDPZ3ddOUUk3wwv/28unGFP58dn+3C14AHKsleAHOn8Z5JLeQr3cc4fcTe2nwoh4XfTEHMbaTOwExxgo2gHWSajdgAHSsVtC7Z8/KvwcOhPz8qvt79Kj8e/BgWL++8mRYpPIE137S6uNj/fj6Wr+HDbP2h4TAHXdU7rf/TJhg7Y+JsYIZPj7MXXsQH18ffpe+0cosAOt4EyZYJ7KOxo6t7Kc9EOPI/jycckrt+xMTrd/ffWe1uazM+j1xonVyan/+zjwT3n23sl++vtaP/fmZNs16fh33+/hYGRwAN9wAY8ZYJ7QOgZjYrxZamR1/+hNcfXXN9tkDUQ8+CLfeWnWfY4bEE0/AvfdW/vvoUZg61Qpe2J+/wECrD2Fh1vYAhwvEd94JF15obbf/OL5Xxo+3/m3fV1RkZSDYDNy7GezvwbIyWL26ynsnb8duMvYk09UYYqOCCT2SXTWY9vPPNTNoTjml8u9duyoDGGlplX+XlVmBn8JC67myZ5b4+Vn9BGvb+PHWNscf++PHxFgBpOr716+vPI6vr/X+u/LKyjbZ33t9+9YMLkHle2/w4Nr327NfRo2C00+3nrOyMuvHSVkYmoHRTL3uX0Rtz5wA+2df0OLHV97rSG4hc1cfYN7aZHILSxkZH8XNZ/TmnIFd27yCu7urLYMl2N+Xp6YP0SCGl/jwx4M8tHAbPaJDeP3a0fTuFObqJqlWoBkY3p+B8WlSCvd8vJlLR3bn2cuHIk1I03aWCbO/rX0aJ3DvlESnBRT+738/89w3e/ju3kn06qjZlrVKT6c0oRd+xZUnxWWBQfge2N+qV3Dtx6J376pXpNvgavGsL3ew9JtNfP/qjUgbHwtwWr/4wx+sqRz2oAJgAgKQG29s/ZPVWo5FQAC0xbHS0ylJ6IW/w3vQ8flbuv0wf/xgEx1CA3nz+jH0b8ZSq47Hcspr5azjOOlYdY0tNIe3mWKjgpu0XSm7LhFB3HfeANY8MJnHLhzI0RNF3PruRs56bjlvrT7AyeJSVzfRJYwxPL1kV43MJl3FxbvMGBPPvBvHk11QwrSXVrFyz1FXN0kp1YDVe49x//wtnNanA09NH+KWwQuAmVMSCa4WoAj082FQbATPLN3N5OdW8PnmNNry4l1ZueH99QeZ2LejBi/qse+P91FWLfW9tLSUfXfd1/oHmzWr8oq0nf1qcSsa1TOaW1bOwzjhWIDT+sWaNVUDCoAUF1tX3ltbLceirY41a5Y1dcRRWRnm8cd5/ft93PpuEoldrZVGWhS8sB3LKa+Vs47j7GNVo1NImmnmlMRarxTPnJLowlYpTxIa6Md1E3rx21MTWLr9MK+u3Mejn2/nn9/s4Zrx8Vx7aoJXrLMNVnAit7CUwzmFpOUUkJ5dSHpOAWm23/bthSXltd5fV3HxLmN7xfDZ7RO46e0NXPfmeh66YCDXT0hw25Mipdqzn4/kccu7SSR0COXla0YR4Oe+177qm8a5eu8xnli0k7ve38Sbq/bz8K8HVizl2Zq+25VBWk4hj1w4sNUf25uU/rCawLKqF2wCy0op/WFV6x/MSSfFo3pGcyxtNz7OOgF31sn+pk0Vf/51wVYWb01n0yPntu4xajlWm1uzBt+SkqrbiotJX/ItT0RcwPmDu/LPK4YTHNAKWVvOeq2cGQBy5rGq0SkkLVB9FRL7l6RSzWGMISn5OK99v4+vdxzB38eHi4fHcuPpvUns6t5rTOcXlVYJSKRlF1YGK3IKSc8uIL+46pUWH7HW4O4WFURsZDDdIoP4OOkQOQU1M1BcUYBNtb0TRaX8+cOf+GbHEa4c04PHLx7s1idHqm46hcQ7p5Bk5BVyyUurKS4rZ8EfTqN7dIirm9QiZeWGTzem8MzS3RzNK+KiYbH85bzEVu3X9W+uZ3taLqvuPwt/LVZcJ2+dij1h9rcM7xHFS1ePdHVT2sRNb2/gUNZJlvzpDFc3pVUkJR/n0pdXM/f6MYzqGc0d721ixZ6j3HJmb+6bMkBXknQxLeLZBqaNiNOAhWo1IsLohBhGJ8Rw4Fg+b/ywn4+TDvFxUgpn9O/Ezaf3ZkLfDk6/Sl1YUkZatj1LwgpGpOVYgQp7JkVuYc2gQ6fwQGIjg+jTKZSJfTsSGxVEt8jgit+dwwNrrEQxOC5SM5vakbBAP165ZhTPfbObl777hX1H83n5mpF0aOq66kqpVneyuJQb39pAVn4xH91yqscHL8BauvOK0T24YEg3XlnxC6+s3MeS7Ye5cWIv/vCrvoQFtmxYfCjrJMv3HOXOX/XV4EUD6lp23tOnYo/qGc26/ZkYY7wyqzAjt5BO4d7zHb35kLWM6HVv/oifj1BWbnjykiH8Zpwu+e7ONIChlBtK6BjKrGmDufuc/sxbl8zc1clc88Y6BnQN56bTe3PhsFgC/HxanAVUVFrGkZwiW6ZEtSkdtr+Pnyypcb+Y0AC6RQbRIyaEcb1j6GbLoOgWGURsVDBdIoKadSW9vvRf5Z18fISZUwbQv0s4f/lkCxe9uIrXrx3NKd0iGr6zUqpNlJUb7nr/J7al5vDqb0czpHukq5vUqkID/bj73ESuHBvPM0t385/lv/DRhkPcc24iV4zu0eyC2u+vP4gAM8bqyU9DvHUq9qie0Xy+OY20nELiPDwYU5uMvCL6tbQehJtYuCmVfzjUWCstNwT4+hDSGlNGVJvSAIZSbiw6NIA7zurHjaf35vOf0njt+33c8/Fm/rF0F2MSYli280hF3YjU7AIemL8VsAIBJWXlHMkttKZw2DIn0nMKSbP9Ts8p4NiJ4hrHjAz2rwhEDI+PIjbSypiwT/XoGhnUplXcNbOpfbp4eBwJHUK56e0NXPryav41YzjnDmrlitlKeQB3mJ4668sdLNt5hMcvHsTZA7s49djOFBsVzPMzhnPtaQk88eUOHpi/lbdWH+ChCwYysV/Hhh/AQXFpOR9tOMRZAzp75Ylra/PWCxajelp1VZKSj3vd+6C83HA0r4jOXpKB8czS3TVqrxWXlfPM0t0e/z70dhrAUMoDBPn7csWYHlw+ujsr9hzlte/38eWW9Bq3KygpY+Ynm3nqq50czSuivNoE07BAPytTIiqYQbERFYGJbvYgRWQQoS1MoVWquYb1iOKLOydy89sbuPmdJGZOSeQPk/o4PQ3XHU4gVftUfSnp6oFpZ5jzw37mrj7AjRN78btTE5xyTFcb3iOKj289la+2Heapr3ZyzRvrOGtAZx6cOoC+nRt3tfnrHYc5dqKYq8f3bOPWeg9vvGAxoGs4wf6+bEw+zkXDYl3dnFaVdbKY0nJDFy8pMF9XgXgtHO/+9ExFKQ8iIkxK7MykxM51FsAqKTOc3q+TlTkRFVyRTdEtMojwIH+nt1mppugSEcSHt5zKXz7ZwjNLd7P7cB7/uGxom2b9OHKHE0jVfj2zdHedS0k74/23dPthZi3awXmDuvLg1FPa/HjuRESYOqQbZw3ozFurD/Dit3uZ8q/vuWZcPH88uz8xoQH13n/e2oN0jw7mjH6dnNRi5Y78fH0Y3iOKpOTjrm5Kq1q4KZW/L94JwL+X7SEy2N/jvxO9tQ5Le6ABDKU8VF0fvHFRwTx7+TAXtEip1hHk78u/rxxOYtdwnlm6mwOZ+UwfGcdrK/e3WVZEaVk52QUlPLl4p0tPINuSZpa4v7qu/KVmF3D7vI306hhKQsdQenUMpXfHUKIbOKluip8OZfPHDzYxrHsUz88Y3m6r7wf5+3LLmX24bFR3nl+2h3fWJrNgUyp3Te7H705NqLW+096ME6zZl8nMKYnNrp+hvEdYoC9r9mXS6/5FXvFZWz2wn3WyxCsC+95ah6U90ACGUh5KP3iVNxMRbv9VX/p1DuP29zby2Oc5FfsayoooLCnj+MlisvKLyT5ZwvGTxRw/WUJ2fjFZJ6tuO55fzPGTxeTVspKOo9TsAm5+ewO9O4XRu2MovTpZJ5AxoQEeUWleM0s8Q12B6UA/H3ak57Jk+2HKHOYGRgb7VwQz7IEN+09jpgM6BrVEICrEn9evHU2wFrGjQ1ggT0wbwu9OTeDvi3byxKKdvLM2mQfOP4Upg7pU+X//3rqD+NlWOFHt28JNqazYcwwAg+d/1hpjeHrJLq8M7HtrHZb2QIypLQnde3nzeu2q/dErqqo9GPv3ZWTkFdXYHhrgy6QBnck+WczxfHtQorhGUS5HYYF+RIX4Ex0SUPE7JrTy738t21PryjtBfj50jwkhOTOfkrLK782IIL+KoEbvTqH06hhWcQLZmJPAtv4/bA/mXPziqlqfw7ioYFbdf1aLj1PXWu3tQWuOK6oHmsAKTD81fUhFceaU4wXsP3aCfUfzOZCZz/5j+ew/mk9aTmGVx+ocHlgloGH/ie8QQqCfb63HCvTz4elLh+r3SC2W787g74t28nPGCcb2iuHhCwbyy9ET/GPJLtJyCgn29+Gp6frctXcTZn9baxDS31c4+5QudI0MomtEEF0jg+gSUfl3c6dJtvQ7JL+olPScAlKzrWLvaTn23wWkZxeSllNQ53eqAPtnX9CsdivVGHWNLTQDQykP5o0FsJSq7mgtJ94A+cVl7EzLJSrEWjlnYGwE0SH+RIUEEB0SQHSIP9GhlX9HhvgT6Ff/IDEy2L/eE8jSsnJSswvYdyyffUfzK04k1+zLZP6m1CqPFRsZRO9OVkDDCm6E0qdTGLFRwfj6SJOyIowx5BWVku0QqDluC9xk27NJatlW/apZdVqszL00dEXQ39enIhBx1oCq9y0oLiM5ywpm7M+0/T6Wz7KdR6qsOOUjEBcdTEZuEUWlVU9Mikq1An9dJiV2ZmLfjnzw4yGe/2YPF774A74ilNkuBBaUlHv0lXbVOur6TC0pM+w+ksfKPUfJL675uRwV4k/XCCuo0c0e3LAFO+zbokL8q2T+NPQdUlxazuEcKwiRnlNAWnblSnRp2QWkZReQWy37UMQKfnaLDOaUbhGcNaAzHycdIqegZpai1opQrqIZGEoppdxaXVe0Wit7oLrmXtE6WVxqXQ2vCG7ks++oFeDIK6oc/AX4+tCzQwiHjp+s9cpWSIAvE/t2rDr9xVb9vTYiVuDFnlUSExJgC+JUBnCeXbqLrFoySzQDo3Yich7wb8AXeN0YM7uu23rCuCKnoIQDx6yMDft78/PNabXeVq+qNiy3sITTnvqWE0U1T+ra6nNJeYbGfF/lFZZULHN/OKeQI7mFHM4t5HBOEYdzCzicU0RmfhHVT9EC/Xwqsja6RAbx3a6MWt+D/r5CVEhArcH/qBB/YiODiY2yVp+Ljar8u1ukFTTx961a56WhzDCl2opmYCillPJIzq730tzMppAAPwbFRjIoNrLKdmMMx04U24IbVkBj37F8fs44UevjnCwu40BmPtEhAfTpFEZ0qH9lQMKeXWLbFhMSQESwf4OFA0MCfLVmTiOJiC/wEnAOkAL8KCKfG2N2uLZlzRcZ7M+wHlEM6xFVsS0p+bhW4G+miCB/8ms5cQTNamrvGvN9FR7kT3iQf71L9JaUlZORV1QR4Ei3BzpyrGDHlpTsWoMX1n0NZyV2pltUkC1YEUy3KCuLIySg6ad+WitCuRuPD2A05SqJUkopz+PpgycRoVN4IJ3CAxnbK6Zie31X6r7+85mt2gZPfw6dbCyw1xizD0BEPgAuBjw2gFEbLQTdMroEo6pNa33W+vv6EBcVTFw976cJs/9HanZhje1xUcE8fdnQpjW8ATplWbkTjw5geONVEqWUUjV54+DJUzJL2qE44JDDv1OAcS5qS5vRoFbLaABI1cVZn7UzpwzQ96Bqlzw6gEE7uUqilFLK++gJpNuqbT5OldnoInIzcDNAfHy8M9rUJjSo1Xz6/1e5mr4HVXvl6QGMRl0l8ZaBhlJKKe+iJ5BuKQXo4fDv7kCVipfGmFeBV8Eq4um8pil3ov9/lavpe1C1Rz4N38StNXiVBKyBhjFmtDFmdKdOnZzQLKWUUkp5qB+BfiLSS0QCgCuBz13cJqWUUkrh+RkYDV4lUUoppZRqLGNMqYjcASzFKhA+xxiz3cXNUkoppRSeH8CouEoCpGJdJfmNa5uklFJKKU9mjFkMLHZ1O5RSSilVlUcHMPQqiVJKKaWUUkop1T54dAAD9CqJUkoppZRSSinVHnh6EU+llFJKKaWUUkq1AxrAUEoppZRSSimllNvTAIZSSimllFJKKaXcngYwlFJKKaWUUkop5fbEGOPqNjiViBwFklv5YTsCx1r5Md2BN/bLG/sE3tkvb+wTeGe/vLFPoP1qip7GmE6t/JgeoY3GFeCd7z9v7BN4Z7+8sU+g/fIk3tgn8M5+tVWfah1btLsARlsQkQ3GmNGubkdr88Z+eWOfwDv75Y19Au/slzf2CbRfyrW88XXyxj6Bd/bLG/sE2i9P4o19Au/sl7P7pFNIlFJKKaWUUkop5fY0gKGUUkoppZRSSim3pwGM1vGqqxvQRryxX97YJ/DOfnljn8A7++WNfQLtl3Itb3ydvLFP4J398sY+gfbLk3hjn8A7++XUPmkNDKWUUkoppZRSSrk9zcBQSimllFJKKaWU29MARiOIyBwRyRCRbbXsu1dEjIh0tP1bROQFEdkrIltEZKTzW9ywJvbpaltftojIahEZ5vwWN05T+uWwfYyIlInIZc5raeM1tU8iMklEfhKR7SKywrmtbbwmvgcjReQLEdls69f1zm9x49TWLxF5TERSba/LTyIy1WHfA7bPi90iMsU1ra5fU/okIueISJKIbLX9Pst1La9fU18r2/54ETkhIvc6v8UNa8b7b6iIrLH9v9oqIkGuaXn74o3jCtCxRbXtOrZwAW8cW3jjuAK8c2zhjeMKcL+xhQYwGmcucF71jSLSAzgHOOiw+Xygn+3nZuBlJ7SvOebS+D7tB840xgwFZuHec7fm0vh+ISK+wNPAUmc0rpnm0sg+iUgU8B/gImPMIOByJ7WxOebS+NfqdmCHMWYYMAl4TkQCnNDG5phLLf0CnjfGDLf9LAYQkYHAlcAg233+Y3tPupu5NLJPWOuAX2iMGQJcC7zjpDY2x1wa36+KfcBXbd6y5ptL499/fsC7wK22z4tJQImzGtrOzcX7xhWgYwv7dh1buM5cvG9sMRfvG1eAd44t5uJ94wpws7GFBjAawRizEsiqZdfzwF8Ax0IiFwNvG8taIEpEujmhmU3SlD4ZY1YbY47b/rkW6N72LWyeJr5WAHcCnwIZbdy0Zmtin34DzDfGHLTd11v6ZYBwEREgzHa/0jZvZDPU06/aXAx8YIwpMsbsB/YCY9uscc3UlD4ZYzYZY9Js/9wOBIlIYJs1rgWa+FohItOAfVj9cktN7NO5wBZjzGbbfTONMWVt1jhVwRvHFaBjCwc6tnARbxxbeOO4ArxzbOGN4wpwv7GFBjCaSUQuAlLtL46DOOCQw79TbNvcXj19cvR73D9KWEVd/RKROOAS4L8uaVgL1PNa9QeiRWS5LcXudy5oXrPV068XgVOANGAr8EdjTLmz29dCd9hSpeeISLRtm8d+XtjU1idHlwKbjDFFzm5YC9Xol4iEAvcBf3Nt05qttteqP2BEZKmIbBSRv7iyge2dN44rQMcWnkTHFh43tvDGcQV459jCG8cV4KKxhQYwmkFEQoC/Ao/UtruWbW6/1EsDfbLf5ldYg4z7nNWulmqgX/8C7vO0K44N9MkPGAVcAEwBHhaR/k5sXrM10K8pwE9ALDAceFFEIpzYvJZ6GeiD1fZ04Dnbdo/8vLCpq08AiMggrBTqW5zftBapq19/w0qVPOGqhrVAXX3yAyYCV9t+XyIik13SwnbOG8cVoGML57aqZXRs4XFjC28cV4B3ji28cVwBLhxb+LXmg7UjfYBewGYr64zuwEYRGYsV6ezhcNvuWJFdd1dnn4wxh0VkKPA6cL4xJtOF7Wyq+l6r0cAHtu0dgakiUmqMWeiqxjZSQ++/Y8aYfCBfRFYCw4A9rmpsE9TXr+uB2cbVlKiAAAAgAElEQVRa93mviOwHBgDrXdXYpjDGHLH/LSKvAV/a/umpnxf19QkR6Q4sAH5njPnFBc1rtnr6NQ64TET+AUQB5SJSaIx50QXNbJIG3n8rjDHHbPsWAyOB/zm9kcobxxWgYwsdW7ieV44tvHFcAd45tvDGcQW4dmyhGRjNYIzZaozpbIxJMMYkYL1QI40xh4HPgd+JZTyQY4xJd2V7G6O+PolIPDAf+K0xxhO+rCrU1y9jTC+H7Z8Af/CAAUZD77/PgNNFxM921WEcsNOFzW20Bvp1EJgMICJdgESsOYMeQarOV78EsFdx/hy4UkQCRaQXVpE+tx84Qd19EqvY2yLgAWPMKle0rSXq6pcx5nSH9+a/gCc9ZZBRz/tvKTBURELEKrp1JrDD2e1T3jmuAB1boGMLl/PWsYU3jivAO8cW3jiuANeOLTQDoxFE5H2sCqodRSQFeNQY80YdN18MTMUqmnMSK7rrdprYp0eADliVjAFKjTGjndLQJmpivzxCU/pkjNkpIkuALUA58LoxpsZSYu6gia/VLGCuiGzFSo+8zx7ZdTe19QuYJCLDsdI4D2BLfTTGbBeRj7A+2EuB290x7bgpfQLuAPpipRg/bNt2rnHDom9N7JdHaOL777iI/BP40bZvsTFmkSva3d5447gCdGzhSXRsAXjI2MIbxxXgnWMLbxxXgPuNLcTKmlJKKaWUUkoppZRyXzqFRCmllFJKKaWUUm5PAxhKKaWUUkoppZRyexrAUEoppZRSSimllNvTAIZSSimllFJKKaXcngYwlFJKKaWUUkop5fY0gKGU8kgislxE3HLJPaWUUkp5Fh1XKOUZNIChlFJKKaWUUkopt6cBDKWUU4jIX0TkLtvfz4vIt7a/J4vIuyJyroisEZGNIvKxiITZ9o8SkRUikiQiS0WkW7XH9RGRt0TkCef3SimllFKuoOMKpdonDWAopZxlJXC67e/RQJiI+AMTga3AQ8DZxpiRwAbgbtv+/wMuM8aMAuYAf3d4TD9gHrDHGPOQc7qhlFJKKTeg4wql2iE/VzdAKdVuJAGjRCQcKAI2Yg04Tgc+BwYCq0QEIABYAyQCg4FvbNt9gXSHx3wF+MgY4zj4UEoppZT303GFUu2QBjCUUk5hjCkRkQPA9cBqYAvwK6APsB/4xhhzleN9RGQIsN0Yc2odD7sa+JWIPGeMKWyzxiullFLKrei4Qqn2SaeQKKWcaSVwr+3398CtwE/AWmCCiPQFEJEQEekP7AY6iciptu3+IjLI4fHeABYDH4uIBmSVUkqp9kXHFUq1MxrAUEo50/dAN2CNMeYIUAh8b4w5ClwHvC8iW7AGHgOMMcXAZcDTIrIZa1BymuMDGmP+iZU2+o6I6GeaUkop1X7ouEKpdkaMMa5ug1JKKaWUUkoppVS9NKqolFJKKaWUUkopt6cBDKWUUkoppZRSSrk9DWAopZRSSimllFLK7WkAQymllFJKKaWUUm5PAxhKKaWUUkoppZRyexrAUEoppZRSSimllNvTAIZSSimllFJKKaXcngYwlFJKKaWUUkop5fY0gKGUUkoppZRSSim3pwEMpZRSSimllFJKuT0NYCillFJKKaWUUsrtaQBDKaWUUkoppZRSbk8DGEoptyUic0XkifZ6fKWUUkq1jIgcEJGz2+vxlfI2GsBQqh0TkcdE5F0nH/MKEdkpInkiskNEpjnz+K1FRC4QkR9EJFtEDovIayIS7up2KaWUUs7k7LGEiCSIiBGREw4/Dzvr+K1JRH4lIt+JSI6IHKhl/ywR2SoipSLymPNbqJT70QCGUqrZRMSvibePA94F7gYigJnAeyLS2dltaQWRwBNALHAK0B14xsltUEoppTxaC76/o4wxYbafWS5uS3PlA3OwxkO12Qv8BVjktBYp5eY0gKFUOyAi94lIqi3rYbeITBaR84AHgRm2qxebbbeNFZHPRSRLRPaKyE0Oj/OYiHwiIu+KSC5wnYj4iMj9IvKLiGSKyEciElNHU7oD2caYr4xlEdaXd596mt9RRL6xtX2FiPR0aI8RkdtF5GfgZ9u2f4vIIRHJFZEkETm9Wvs/EpG3bY+3XURGO+wfISIbbfs+BILqapQx5j1jzBJjzEljzHHgNWBCPf1QSimlPJYbjSWaY4wt6/O4iLwpIkG2tkwSkRRb3w4Db4pItIh8KSJHbbf/UkS6O7R/uS0zYpXtufhaRDo67P+tiCTb+vHX+hpljFlvjHkH2FfH/reMMV8Bea3yLCjlBTSAoZSXE5FE4A5gjDEmHJgCHDDGLAGeBD60Xb0YZrvL+0AKVmbBZcCTIjLZ4SEvBj4BooB5wF3ANOBM232OAy/V0ZwNwE4RuUhEfG3TR4qALfV04WpgFtAR+Ml2TEfTgHHAQNu/fwSGAzHAe8DH9oGKzUXAB7b2fw68aHueAoCFwDu2+34MXFpPu6o7A9jehNsrpZRSHsHNxhJ2ybbgw5uOAYQ6XG1rcx+gP/CQw76uWN/7PYGbsc6P3rT9Ox4owDZWcPAb4HqgMxAA3AsgIgOBl4Hf2vrRAevijVKqlWgAQynvVwYEAgNFxN8Yc8AY80ttNxSRHsBE4D5jTKEx5ifgdawvYrs1xpiFxphyY0wBcAvwV2NMijGmCHgMuKy2NExjTBnwNlZgocj2+xZjTH497V9kjFlpe+y/Aqfa2mn3lDEmy9YWjDHvGmMyjTGlxpjnbH1PdLj9D8aYxba2vAPYB1vjAX/gX8aYEmPMJ1jBkAaJyDnAtcAjjbm9Ukop5WHcZiwBHAPGYAUYRgHh1Ly4Ud2LxphDxpgs4O/AVQ77yoFHjTFFxpgC2xjiU1uGZZ7t9mdWe7w3jTF7bG3/COvCCVjBmi8dxi0P2x5fKdVKNIChlJczxuwF/oQ1GMgQkQ9EJLaOm8cCWbYvbLtkIM7h34eq3acnsECsYpbZwE6sgU6X6g8uVhXufwCTsK5YnAm8LiLDq9+2tuMZY04AWbZ21toeEblHrCKhObb2RGJlb9gddvj7JBBkGyDFAqnGGOOwP7medtmPNx4rEHOZMWZPQ7dXSimlPI07jSWMMSeMMRtsFyqOYGWGnCsiEfV0wfF4yVQdRxw1xhTa/yEiISLyim0aSC6wEogSEV+H+1QfS4TZ/o6l6rglH8isp11KqSbSAIZS7YCtXsNErAGCAZ6276p20zQgRqquphEPpDo+XLX7HALON8ZEOfwEGWNSqWk4sNI28Cg3xvwIrAPqW16sIttCRMKw0jzTamuPrd7FfcAVQLQxJgrIAaSex7dLB+JExPG28fXdQURGYE1DucEY879GHEMppZTySG40lqjRNNvv+r7rHTM346ljHGFzD1bm5jhjTATWFNGGHt8unarjlhCsaSRKqVaiAQylvJyIJIrIWSISCBRizeUss+0+AiSIiA+AMeYQsBp4SkSCRGQo8HvqT838L/B3e3FNEekkIhfXcdsfgdPtGRe2AMDp1F8DY6qITLTVqJgFrLO1szbhQClwFPATkUewVjtpjDW2+94lIn4iMh0YW9eNRWQwsAS40xjzRSOPoZRSSnkcdxpLiMg4W3t8RKQD8AKw3BiTU8/j3y4i3W2FQR8EPqzntuG2/mXbbv9oPbet7hPg1w7jlsep53zL1ocgrCmsYnu+Ahz2+9v2+2CNa4KqZYIo1e5oAEMp7xcIzMaaM3oYq+DUg7Z9H9t+Z4rIRtvfVwEJWFcnFmDNC/2mnsf/N1YWwtcikgesxSqqWYMxZgVW+uknttt+CjxpjPm6nsd/D2vwkIU11/Xqem67FPgK2IOVIlpIzTTVWhljioHpwHVYxcNmAPPrucs9QCfgDalch16LeCqllPJGbjOWAHpjXUDIA7Zh1dS6qo7b2r0HfI212sc+rGXQ6/IvIBirr2ttx2oUY8x24Hbb8dKxxhMp9dzlDKxgyWIqC4Y6joles227CqsOWAFVa4ko1e5I1eneSimllFJKKaWUUu5HMzCUUkoppZRSSinl9jSAoZRSSimllFJKKbenAQyllFJKKaWUUkq5PQ1gKKWUUkoppZRSyu1pAEMppZRSSimllFJuz8/VDXC2jh07moSEBFc3QymllPIaSUlJx4wxnVzdDlfQcYVSSinV+uoaW7S7AEZCQgIbNmxwdTOUUkopryEiya5ug6vouEIppZRqfXWNLXQKiVJKKaWUUkoppdyeBjCUUkoppZRSSinl9jSAoZRSSimllFJKKbfX7mpgKKWUal9KSkpISUmhsLDQ1U3xeEFBQXTv3h1/f39XN0UppZRyGR1btJ6mji00gKGUUsqrpaSkEB4eTkJCAiLi6uZ4LGMMmZmZpKSk0KtXL1c3RymllHIZHVu0juaMLXQKiVJKKa9WWFhIhw4ddIDRQiJChw4d9GqTUkqpdk/HFq2jOWMLDWAopZTyejrAaB36PCqllFIW/U5sHU19HjWAoZRSSrmR5cuXs3r16hY9RlhYWCu1RimllFKezpvGFloDQymlnGDhplSeWbqbtOwCYqOCmTklkWkj4lzdLFULV79Wy5cvJywsjNNOO81px1Tuw9XvP6WUUq3P1Z/t3jS20AwMpZRqYws3pfLA/K2kZhdggNTsAh6Yv5WFm1Jd3TRVTVu+VtOmTWPUqFEMGjSIV199FYAlS5YwcuRIhg0bxuTJkzlw4AD//e9/ef755xk+fDjff/891113HZ988knF49ivgJw4cYLJkyczcuRIhgwZwmeffdbiNirX0s8KpZTyPjq2aF2agaGUUm3smaW7KSgpq7KtoKSMZ5bu1iurTva3L7azIy23zv2bDmZTXFZeZVtBSRl/+WQL768/WOt9BsZG8OiFgxo89pw5c4iJiaGgoIAxY8Zw8cUXc9NNN7Fy5Up69epFVlYWMTEx3HrrrYSFhXHvvfcC8MYbb9T6eEFBQSxYsICIiAiOHTvG+PHjueiii3ROrgfTzwqllPI8OrZwLg1gKKVUG0vLLmjSduU61QcYDW1vihdeeIEFCxYAcOjQIV599VXOOOOMimXDYmJimvR4xhgefPBBVq5ciY+PD6mpqRw5coSuXbu2uK3KNfSzQimlvI+OLVqXBjCUUqqNxUYFk1rLCUhsVLALWtO+NXQ1Y8Lsb2t9reKigvnwllObfdzly5ezbNky1qxZQ0hICJMmTWLYsGHs3r27wfv6+flRXm4NcowxFBcXAzBv3jyOHj1KUlIS/v7+JCQk6BKnHk4/K5RSyvPo2MK5tAaGUkq1sZlTEgnyr/pxG+zvy8wpiS5qkarLzCmJBPv7VtnWGq9VTk4O0dHRhISEsGvXLtauXUtRURErVqxg//79AGRlZQEQHh5OXl5exX0TEhJISkoC4LPPPqOkpKTiMTt37oy/vz/fffcdycnJLWqjcr22ev8ppZRyHR1btC4NYCilVBubNiKO2yf1rfh3l4hAnpo+ROe0u6FpI+J4avoQ4qKCEayrI63xWp133nmUlpYydOhQHn74YcaPH0+nTp149dVXmT59OsOGDWPGjBkAXHjhhSxYsKCi0NZNN93EihUrGDt2LOvWrSM0NBSAq6++mg0bNjB69GjmzZvHgAEDWtp95WL2919UsD+gnxVKKeUNdGzRusQY4+o2ONXo0aPN/7N35/F111X+x18n+560SdqmvS1JoZSWNmUpmy0iIlAEAR1AcKEqUgUdnZ+KwKjDCKIyKI44KFOFARRBtgGUpZRF1rLUKd0ohTYtbZobmi65SZvcrJ/fH9/vbdM2abZ7c+9N3s/H4z6S+/lu52bG8snJ53PO0qVL4x2GiIwwz6yuZcEfvUz3ny47gblTSuIc0cixZs0apk2bFu8who3ufp5m9g/n3Ow4hRRXsZhXrNoS4pzfvMJvLjmaT80aH9V7i4jI4GluEV39mVtoBYaIyBCobdi7f3DDtl1xjEQkeZnZnWa21cxW7Tf+z2a21sxWm9l/dBm/1szW+cfO7DI+zx9bZ2bXdBmvMLM3zOx9M/uLmWUMzSfb1+Fj88lIS2HlllA8Hi8iIpKwlMAQERkCNfVh0lKMnIxUNmxrinc4IsnqLmBe1wEzOxU4D6h0zh0J/MIfnw5cDBzpX/NbM0s1s1TgNuAsYDpwiX8uwE3Ar5xzU4CdwGUx/0TdyEhLYVpZAcs318fj8SIiIglLCQwRkSFQG2pmbEEW5cW5WoEhMkDOuZeAHfsNXwH83DnX4p+z1R8/D7jfOdfinNsArAOO91/rnHNVzrlW4H7gPPOa3H8ceMi//m7g/Jh+oIOYFShk1ZYQHZ0ja6uviIjIwcQsgdHdMk8zu8HMVpjZ22b2jJmN98fNzG71l3KuMLNjulwz31/K+b6Zze8yfqyZrfSvudWfeIiIJKRgKMz4oiwqSnLZuF0rMESi6HDgZH/rx4tmdpw/PgHY3OW8an+sp/FioN45177feFxUBorY3dpBVZ0SniIiIhGxXIFxF/st8wRuds5VOueOAv4G/Js/fhYwxX8tAH4HYGajgeuAE/D+YnKdmY3yr/mdf27kuv2fJSKSMIKhMOMKsykvyWHzjibaOjrjHZLIcJEGjAJOBK4CHvD/qNHdHzbcAMYPYGYLzGypmS2tq6sbWNS9mBUoBGB5tepgiIiIRMQsgdHdMk/nXEOXt7nsnRicB9zjPK8DRWZWBpwJLHbO7XDO7QQWA/P8YwXOuSXOa6NyD3Fc5ikicjDOOWpDYcoKs6goyaO901G9szneYYkMF9XAI/4c4k2gEyjxxyd2OS8A1BxkfBve/CNtv/EDOOcWOudmO+dml5aWRvXDREwuzSM3I5WV1aqDISIiEjHkNTDM7EYz2wx8nr0rMPq7zHOC//3+4yIiCWfH7lZaOzr9BEYOABu37Y5zVJLM8vLyAKipqeGCCy446Ln/+Z//SVNT/7Yt/f3vf+ecc84ZcHxD7FG82hWY2eFABl4y4nHgYjPLNLMKvNWabwJvAVP8jiMZeIU+H/f/IPICEPmBzgceG9JP0kVqinHkhEKtwBARkSGRLHOLIU9gOOd+4JybCNwLfNMfjtkyTxiapZ4iIj0JhrwWqpEVGABVSmAktmAQTjkFamuH7JEdHR39vmb8+PE89NBDBz1nIJOMRGVm9wFLgKlmVm1mlwF3ApP9mlv3A/P91RirgQeAd4CngW845zr8GhffBBYBa4AH/HMBrga+Y2br8Gpi3DGUn29/swKFvBNsoLVdW85ERJKe5hZREc8uJH8G/sn/vr/LPKv97/cf79ZQLPUUEelJJIExrjCbUTnpFGSlaQVGorvhBnjlFe9rFGzcuJEjjjiC+fPnU1lZyQUXXEBTUxPl5eVcf/31zJ07lwcffJD169czb948jj32WE4++WTeffddADZs2MBJJ53Ecccdx49+9KN97jtjxgzAm6R873vfY+bMmVRWVvKb3/yGW2+9lZqaGk499VROPfVUAJ555hlOOukkjjnmGC688EJ27fKKRD799NMcccQRzJ07l0ceeSQqnzvanHOXOOfKnHPpzrmAc+4O51yrc+4LzrkZzrljnHPPdzn/Rufcoc65qc65p7qMP+mcO9w/dmOX8Srn3PHOucOccxdGOpvES2WgiNb2Tt77sDGeYYiISDRobhGVz53W+ynRY2ZTnHPv+2/PBd71v38c+KaZ3Y9XsDPknAua2SLgp10Kd54BXOuc22FmjWZ2IvAGcCnwm6H7JCIifVcb8updjC/MwsyoKM1jgxIY8fOxjx04dtFFcOWV0NQEp50Gb74JnZ1w++2wbBksWABf+hJs2wb7L6v8+9/79Ni1a9dyxx13MGfOHL7yla/w29/+FoCsrCxeeeUVAE477TRuv/12pkyZwhtvvMGVV17J888/z7e//W2uuOIKLr30Um677bZu779w4UI2bNjAsmXLSEtLY8eOHYwePZpbbrmFF154gZKSErZt28ZPfvITnn32WXJzc7npppu45ZZb+P73v8/ll1/O888/z2GHHcZnP/vZPv4wJZZmBYoAWF5dz4wJhXGORkREeqS5xZDNLWKWwPCXeX4MKDGzarxuIp80s6l4BbY+AL7un/4k8Em8Hu1NwJcB/ETFDXj7VQGud85FCoNegdfpJBt4yn+JiCScYChMWopRnJcJQEVxDm9t3BnnqKRHH3wAzt+V6Jz3PgomTpzInDlzAPjCF77ArbfeCrDnP+i7du3itdde48ILL9xzTUuLtwDg1Vdf5eGHHwbgi1/8IldfffUB93/22Wf5+te/Tlqa95/20aNHH3DO66+/zjvvvLMnjtbWVk466STeffddKioqmDJlyp74Fi5cGJXPLQM3cXQ2RTnprKwOeX/eERGR5KS5RdTmFjFLYDjnLulmuNu9pH7hrG/0cOxOvP2t+48vBWYMJkYRkaEQDIUZW5BFaopXvqe8JJfHltcQbusgKz01ztGNQAf7q0YoBDt37jvJ2LkT5vmduktK+vxXkf15nT0PfJ+bmwtAZ2cnRUVFvP322326fn/OuT6dc/rpp3PfffftM/7222/3eq0MPTNjpgp5iogkPs0thmxuEc8aGCIiI0Iw1ExZYdae9xUluTgHm3YMj8KKw8oNN3jLO7vq6IjKftVNmzaxZMkSAO677z7mzp27z/GCggIqKip48MEHAW9CsHz5cgDmzJnD/fffD8C9997b7f3POOMMbr/9dtrb2wHYscNbsJifn09jo1dD4cQTT+TVV19l3bp1ADQ1NfHee+9xxBFHsGHDBtavX78nPkkMswJFvPdhI82t/S/EJiIiCUBziz3xRYMSGCIiMVYbCjNuvwQGoDoYiWjJEmht3XestRVee23Qt542bRp33303lZWV7NixgyuuuOKAc+69917uuOMOZs2axZFHHsljj3ldPH/9619z2223cdxxxxEKdf/X+K9+9atMmjSJyspKZs2axZ///GcAFixYwFlnncWpp55KaWkpd911F5dccgmVlZWceOKJvPvuu2RlZbFw4ULOPvts5s6dyyGHHDLozyvRURkopKPT8U5QqzBERJKS5hZRnVuYcz12Hx2WZs+e7ZYuXRrvMERkhHDOccSPnubSkw7hB2dPB6Ah3Eblvz/DNWcdwddPOTTOEQ5/a9asYdq0aXGNYePGjZxzzjmsWrUqrnFEQ3c/TzP7h3NudpxCiqtYzys+bAhzwk+f49/Omc5X5lbE7DkiItJ3mltEV3/mFlqBISISQzub2mhp76SsMHvPWEFWOiV5GWqlKiK9GluQxdiCTFZu0QoMERERJTBERGIo6LdQ7VoDA6C8OJcqJTBGjPLy8mHxFxKJj5kTilheXR/vMEREJIGM1LmFEhgiIjEUrA8D7FMDA7w6GFqBISJ9MStQSFXdbhrCbfEORUREJK6UwBARiaFgg5fAGF+Uvc94eUkuWxtb2N3SHo+wRpyRVu8pVvRzjI/KiUUArFI7VRGRhKH/JkZHf3+OSmCIiMRQbaiZ1BSjJC9zn/HJ6kQyZLKysti+fbsmGoPknGP79u1kZWX1frJEVeWEQgCWK4EhIpIQNLeIjoHMLdJiGI+IyIgXrA8zNj+T1BTbZ7zcT2Bs3L6bGf4vJxIbgUCA6upq6urq4h1K0svKyiIQCMQ7jBFnVG4Gk0bnsHKL6mCIiCQCzS2ip79zCyUwRERiKBgKU7bf9hHwingCbKjTCoxYS09Pp6JC7Scluc0MFPL2JiUwREQSgeYW8aMtJCIiMVTbED6ggCdAdkYqZYVZbNiuBIaI9G5WoJAt9c1s39US71BERETiRgkMEZEYcc5RU99MWUH3+/rKi3NVA0NE+qQy4BXyXKE6GCIiMoIpgSEiEiP1TW20tHd2u4UEoKJUrVRFpG9mTCjEDJZXaxuJiIiMXEpgiIjESDDktVAt62YLCUBFcS47m9qob2odyrBEJAnlZaZxWGmeVmCIiMiIpgSGiEiMBEPNAN3WwACoUCtVEemHykARK6pDatsnIiIjlhIYIiIxElmBMb6w+y0kXVupioj0pjJQyLZdLXv+bRERERlplMAQEYmR2lCY1BSjND+z2+OTRueQYmqlKiJ9UxkoBGCF6mCIiMgIpQSGiEiM1ISaGZOfSWqKdXs8Iy2FwKgcNmxvGuLIRCQZTSsrIC3FWK46GCIiMkIpgSEiEiO1oXCPBTwjykty2bBt1xBFJCLJLCs9lSPK8rUCQ0RERiwlMEREYsRLYHRf/yJickkuG7c1qSifiPSJCnmKiMhIpgSGiEgMOOeoCTX32IEkorw4h10t7WzbpVaqItK7ygmFNIbb2aitZyIiMgIpgSEiEgOh5jbCbZ29biGpKM0D1EpVRPqmMlAEqJCniIiMTEpgiIjEQKTNYW9bSCqK/VaqSmCISB8cPjaPrPQUlm9WIU8RERl5lMAQEYmBYKgZoNctJBNGZZOealQpgSEifZCWmsKR4wu1AkNEREYkJTBERGJg7wqMgycwUlOMSaNztAJDRPqsMlDI6poG2js64x2KiIjIkIpZAsPM7jSzrWa2qsvYzWb2rpmtMLP/NbOiLseuNbN1ZrbWzM7sMj7PH1tnZtd0Ga8wszfM7H0z+4uZZcTqs4iI9FdtKEyKwZj8zF7PrSjJVQ0MEemzykAhzW0drKtTC2YRERlZYrkC4y5g3n5ji4EZzrlK4D3gWgAzmw5cDBzpX/NbM0s1s1TgNuAsYDpwiX8uwE3Ar5xzU4CdwGUx/CwiIv1SUx9mTH4Waam9/zNbUZLLxu276exUW0QR6d2eQp6qgyEiIiNMzBIYzrmXgB37jT3jnGv3374OBPzvzwPud861OOc2AOuA4/3XOudclXOuFbgfOM/MDPg48JB//d3A+bH6LCIi/VXb0HsL1Yjyklxa2jupbQjHOCoRGQ4qinPJz0xjuepgiIjICBPPGhhfAZ7yv58AbO5yrNof62m8GKjvkgyJjIuIJIRgKMz4or4lMCpKvE4k2kYiIn2RkmLMDBSyou0NML8AACAASURBVForMEREZGSJSwLDzH4AtAP3Roa6Oc0NYLyn5y0ws6VmtrSurq6/4YqI9ItzjtpQmHEFB2+hGqEEhoj0V2WgiHdrG2hp74h3KCIiIkNmyBMYZjYfOAf4vHMuknSoBiZ2OS0A1BxkfBtQZGZp+413yzm30Dk32zk3u7S0NDofRESkBw3N7TS1dvTagSRibH4W2empSmCISJ9VBgpp63C8G2yMdygiIiJDZkgTGGY2D7gaONc519Tl0OPAxWaWaWYVwBTgTeAtYIrfcSQDr9Dn437i4wXgAv/6+cBjQ/U5REQOJtjQDEBZH7eQpKQYhxSrlaqI9F1loBCAFaqDISIiI0gs26jeBywBpppZtZldBvwXkA8sNrO3zex2AOfcauAB4B3gaeAbzrkOv8bFN4FFwBrgAf9c8BIh3zGzdXg1Me6I1WcREemPYMgrxtnXFRigVqoi0j8TirIpzs1guepgiIjICJLW+ykD45y7pJvhHpMMzrkbgRu7GX8SeLKb8Sq8LiUiIgklWO8lMMYV9q0GBngJjMXvfEh7R2efWq+KyMhmZlQGCrUCQ0RERhTNkkVEoqw21EyKwZj8zD5fU16SS3unY0t9cwwjE5HhpDJQxLqtu9jd0t77ySIiIsOAEhgiIlEWDIUpzc8kvR8rKSb7nUiqtI1EpEdmdqeZbTWzVd0c+56ZOTMr8d+bmd1qZuvMbIWZHdPl3Plm9r7/mt9l/FgzW+lfc6uZddf1LGFUBgrpdLC6piHeoYiIiAwJJTBERKIsGAr3a/sIeCswABXyFDm4u4B5+w+a2UTgdGBTl+Gz8IqCTwEWAL/zzx0NXAecgLcV9TozG+Vf8zv/3Mh1BzwrkVQGigAV8hQRkZFDCQwRkSgLhpoZ348CngDFuRnkZ6apkKfIQTjnXgJ2dHPoV8D3Addl7DzgHud5Ha/9ehlwJrDYObfDObcTWAzM848VOOeW+N3O7gHOj+XnGazS/EzGF2apkKeIiIwYSmCIiESRc85fgdG/BIaZUVGqTiQi/WVm5wJbnHPL9zs0Adjc5X21P3aw8epuxrt75gIzW2pmS+vq6gb5CQanMlCkFRgiIjJiKIEhIhJFDeF2mlo7+tVCNaK8WAkMkf4wsxzgB8C/dXe4mzE3gPEDB51b6Jyb7ZybXVpa2tdwY6JyYiEfbG8i1NQW1zhERESGghIYIiJRVBvyWqiW9bMGBnitVGvqm2lp74h2WCLD1aFABbDczDYCAeD/zGwc3gqKiV3ODQA1vYwHuhlPaJUT/DoYW7QKQ0REhj8lMEREoigY8tqgDmQFRkVJLp0ONu9oinZYIsOSc26lc26Mc67cOVeOl4Q4xjlXCzwOXOp3IzkRCDnngsAi4AwzG+UX7zwDWOQfazSzE/3uI5cCj8Xlg/XDzEAhACtUB0NEREYAJTBERKIo6K/A6G8NDPASGABVddpGItIdM7sPWAJMNbNqM7vsIKc/CVQB64DfA1cCOOd2ADcAb/mv6/0xgCuAP/jXrAeeisXniKbC7HQqSnJZvlkrMEREZPhLi3cAIiLDSTAUxgzGFgygBkaklep2JTBEuuOcu6SX4+VdvnfAN3o4707gzm7GlwIzBhfl0KsMFPJGVXfNWURERIYXrcAQEYmi2lAzpXmZpKf2/5/Xwux0RudmqJCniPRLZaCI2oYwWxvC8Q5FREQkppTAEBGJomAoPKD6FxEVJepEIiL9U6k6GCIiMkIogSEiEkVeAqP/HUgi1EpVRPrryPEFpBisqFYdDBERGd6UwBARiaLaUHhABTwjJpfm8mFDC02t7VGMSkSGs5yMNA4fm89yrcAQEZFhTgkMEZEoaQi3saulfVBbSMqL/UKe29RKVUT6rjJQyIrqerzapSIiIsOTEhgiIlFS67dQLSsa+BaSSCtVbSMRkf6oDBSxs6mN6p3N8Q5FREQkZpTAEBGJkmAkgTGYFRglOYBaqYpI/6iQp4iIjARKYIiIREmw3vvL57iCgScwcjLSGFuQSVWdEhgi0ndHjCsgIzVFhTxFRGRYUwJDRCRKgqEwZjB2EAkM8LaRaAWGiPRHRloK08ryWa4EhoiIDGNKYIiIREltKExJXiYZaYP7p7WiRK1URaT/KgNFrNrSQGenCnmKiMjwpASGiEiU1ISaB1X/IqKiJJcdu1sJNbVFISoRGSkqA4XsammnatuueIciIiISE0pgiIhESW0oHJUERqSV6gZtIxGRfqgMFAEq5CkiIsOXEhgiIlHiJTAG3kI1YnKpl8DYqG0kItIPh43JIycjVQkMEREZtpTAEBGJgsZwG40t7YyLwgqMiaNzSDFUB0NE+iU1xZgxvlCFPEVEZNhSAkNEJApqQ2GAqGwhyUxLZXxRthIYItJvlYFC3qlpoK2jM96hiIiIRF3MEhhmdqeZbTWzVV3GLjSz1WbWaWaz9zv/WjNbZ2ZrzezMLuPz/LF1ZnZNl/EKM3vDzN43s7+YWUasPouISG+CexIYg99CAmqlKiIDUzmxiJb2TtbWNsY7FBERkaiL5QqMu4B5+42tAj4DvNR10MymAxcDR/rX/NbMUs0sFbgNOAuYDlzinwtwE/Ar59wUYCdwWYw+h4hIr6K5AgP8Vqp1u3FO7RBFpO8qJxQCsHKL6mCIiMjwE7MEhnPuJWDHfmNrnHNruzn9POB+51yLc24DsA443n+tc85VOedagfuB88zMgI8DD/nX3w2cH6OPIiLSq5pQMwBjC6KXwGhsaWf77tao3E9ERoZDinMozE5nhepgiIjIMJQoNTAmAJu7vK/2x3oaLwbqnXPt+42LiMRFbShMSV4mGWnR+We1vMRvpao6GCLSD2ZGZaCQ5Zu1AkNERIafRElgWDdjbgDj3d/cbIGZLTWzpXV1dQMMUUSkZ8FQOGrbRwAmK4EhIgNUGShk7YeNhNs64h2KiIhIVCVKAqMamNjlfQCoOcj4NqDIzNL2G++Wc26hc262c252aWlpVAMXEQEIhpqjmsCYUJRNWoqxUQkMEemnykARHZ2O1TUN8Q5FREQkqhIlgfE4cLGZZZpZBTAFeBN4C5jidxzJwCv0+bjzqtq9AFzgXz8feCwOcYuIANFfgZGWmsKk0TlagSEi/VYZ8At5qg6GiIgMM7Fso3ofsASYambVZnaZmX3azKqBk4AnzGwRgHNuNfAA8A7wNPAN51yHX+Pim8AiYA3wgH8uwNXAd8xsHV5NjDti9VlERA5mV0s7jeF2xkWphWpERUmuEhgi0m/jCrIozc9kRbXqYIiIyPCS1vspA+Ocu6SHQ//bw/k3Ajd2M/4k8GQ341V4XUpEROKq1u9AMr4oeiswwCvk+er6bXR2OlJSuiv9IyJyIDNjVqCQ5VqBISIiw0yibCEREUlawVAY8P7qGU0VJbmE2zr5sDEc1fuKyPBXGSiiattuGsNt8Q5FREQkapTAEBEZpEgCoywGW0gANtRpG4mI9E9loBDnYOUWbSMREZHhQwkMEZFBCtZ7CYyxhZlRve+eBMZ2JTBEpH8qA0UArFQdDBERGUaUwBARGaTahmZK8jLITEuN6n3HFWSRmZaiVqoi0m+jczMIjMpWIU8RERlWlMAQERmkYCjMuCi2UI1ISTHKi9WJREQGZlagSIU8RURkWFECQ0RkkIL1YcYVRLf+RYRaqYrIQFUGCqne2cz2XS3xDkVERCQqlMAQERmkYKg56i1UI8pLctm0o4n2js6Y3F9Ehq9IHYwVKuQpIiLDhBIYIiKDsLulnYZwe0y2kABMLsmlrcNRU69WqiLSPzMmFGAGKzYrgSEiIsODEhgiIoOwt4Vq7FZgAFRt2xWT+4vI8JWflc7kklxWblEdDBERGR6UwBARGYTaPQmM2NTAKC/JAVAnEhEZEK+QZwjnXLxDERERGTQlMEREBiEYagZitwKjNC+TvMw0Nm5visn9RWR4qwwUUtfYQm2DtqGJiEjyUwJDRGQQIltIxhbEJoFhZpSX5FClFRgiMgCVE71CnstVB0NERIYBJTBERAYhGApTnJtBVnpqzJ5RUZKnLSQiMiDTywpISzFWVKsOhoiIJD8lMEREBqE21ByzDiQRFcU5VO9sorVdrVRlZDOzO81sq5mt6jJ2s5m9a2YrzOx/zayoy7FrzWydma01szO7jM/zx9aZ2TVdxivM7A0ze9/M/mJmGUP36WIjKz2Vw8fms1KtVEVEZBhQAkNEZBCCoXDM6l9EVJTm0ulg0w7VwZAR7y5g3n5ji4EZzrlK4D3gWgAzmw5cDBzpX/NbM0s1s1TgNuAsYDpwiX8uwE3Ar5xzU4CdwGWx/ThDY9bEQlaokKeIiAwDSmCIiAyCl8CITQeSiPJir5XqBm0jkRHOOfcSsGO/sWecc+3+29eBgP/9ecD9zrkW59wGYB1wvP9a55yrcs61AvcD55mZAR8HHvKvvxs4P6YfaIhUBooINbfxgYoBi4hIklMCQ0RkgJpa2wk1t8V+C0mJl8BQHQyRXn0FeMr/fgKwucuxan+sp/FioL5LMiQyfgAzW2BmS81saV1dXRTDj43KQCEAy1UHQ0REkpwSGCIiAxTpQBLrLSRFORmMyklnw3YlMER6YmY/ANqBeyND3ZzmBjB+4KBzC51zs51zs0tLSwcS7pA6fGw+mWkprKhWHQwREUluafEOQEQkWdXuSWDEdgsJQHlJLhvqlMAQ6Y6ZzQfOAU5zews9VAMTu5wWAGr877sb3wYUmVmavwqj6/lJLT01henjC1ipBIaIiCQ5rcAQERmgoVqBAd42ko1agSFyADObB1wNnOuc61rk4XHgYjPLNLMKYArwJvAWMMXvOJKBV+jzcT/x8QJwgX/9fOCxofocsTYrUMSqmhAdnSrkKSIiyUsJDBGRAQrWNwPEvAYGQEVxLsFQmObWjpg/SyRRmdl9wBJgqplVm9llwH8B+cBiM3vbzG4HcM6tBh4A3gGeBr7hnOvwV1d8E1gErAEe8M8FLxHyHTNbh1cT444h/HgxVRkopKm1g3Vbd8U7FBERkQHTFhIRkQEKNoQZnZtBVnpqzJ9VUeoX8ty+m2llBTF/nkgics5d0s1wj0kG59yNwI3djD8JPNnNeBVel5JhpzJQBHiFPKeOy49zNCIiIgOjFRgiIgNUGwozriD2qy9ArVRFZHAml+SSl5nGCnUiERGRJKYEhojIANXUNw9J/QvwiniCEhgiMjApKcaMCSrkKSIiyU0JDBGRAaptCFNWNDQJjLzMNMbkZ7JRCQwRGaBZgSLWBBtpbe+MdygiIiIDErMEhpndaWZbzWxVl7HRZrbYzN73v47yx83MbjWzdWa2wsyO6XLNfP/89/02aZHxY81spX/NrWbWXf92EZGYaG7toL6pbUhaqEaUl+RqBYaIDFhloIjWjk7erW2IdygiIiIDEssVGHcB8/YbuwZ4zjk3BXjOfw9wFl57synAAuB34CU8gOuAE/CKal0XSXr45yzoct3+zxIRiZnaBq+F6lDVwABvD7taqYrIQFUGCgFYrm0kIiKSpGKWwHDOvQTs2G/4POBu//u7gfO7jN/jPK8DRWZWBpwJLHbO7XDO7QQWA/P8YwXOuSV+3/Z7utxLRCTmIi1Uh2oLCXgrMLbtaqUh3DZkzxSR4SMwKptROems2KxCniIikpx6TWCY2YVmlu9//0Mze6TrFo9+GuucCwL4X8f44xOAzV3Oq/bHDjZe3c24iMiQCIa8FRhDuYWkwi/kqToYkuyiPLeQPjIzKgNFrNyiFRgiIpKc+rIC40fOuUYzm4u3IuJu/C0eUdRd/Qo3gPHub262wMyWmtnSurq6AYYoIrJXPLaQVKgTiQwfQzG3kG7MChTy3oeNNLW2xzsUERGRfutLAqPD/3o28Dvn3GNAxgCf96G//QP/61Z/vBqY2OW8AFDTy3igm/FuOecWOudmO+dml5aWDjB0EZG9auqbGZWTTnZG6pA9c9LoHMyUwJBhIZpzC+mHykARnQ5W16iQp4iIJJ++JDC2mNl/AxcBT5pZZh+v687jQKSTyHzgsS7jl/rdSE4EQv4Wk0XAGWY2yi/eeQawyD/WaGYn+t1HLu1yLxGRmKsNhRk3hNtHALLSUxlfmK0tJDIcRHNuIf1QOdEv5Kk6GCIikoT6Mlm4CC+RMM85Vw+MBq7q7SIzuw9YAkw1s2ozuwz4OXC6mb0PnO6/B3gSqALWAb8HrgRwzu0AbgDe8l/X+2MAVwB/8K9ZDzzVh88iIhIVwVCYssKh2z4SUaFWqjI8DGhuIYM3Jj+LssIsVqgTiYiIJKG03k5wzjWZ2VZgLvA+0O5/7e26S3o4dFo35zrgGz3c507gzm7GlwIzeotDRCQWgqFmjp5UNOTPrSjJ5bG3t+Ccw1uAJpJ8Bjq3kOiYOaFQhTxFRCQp9aULyXXA1cC1/lA68KdYBiUiksjCbR3sbGqLywqM8pJcGsLt7NjdOuTPFokWzS3ia9bEIjZs202oWS2ZRUQkufRlC8mngXOB3QDOuRogP5ZBiYgkslq/hepQ18AAmBxppbpd20gkqWluEUeVAa8OxkptIxERkSTTlwRGq7/FwwGYWW5sQxIRSWw1oWYAxsdpBQZAVZ0SGJLUNLeIo8oJ3va35dUq5CkiIsmlLwmMB/xK4UVmdjnwLF6hTRGREWnvCoyhT2AERmWTmmJagSHJTnOLOCrMSae8OIcVSmCIiEiS6UsRz1+Y2elAAzAV+Dfn3OKYRyYikqCCfgKjLA5bSNJTU5g0OoeN25qG/Nki0aK5RfzNDBSxdOOO3k8UERFJIL0mMAD8SYUmFiIieB1IinLSyc5Ijcvzy4tzqFIrVUlymlvE16xAIX9dXsPWxjBj8od+NZmIiMhA9JjAMLNG/L2p+x/C63xaELOoREQSWG0ozLiC+E34K0ryeL1qh1qpStLR3CJxVAa8Ohgrq0OcNk0JDBERSQ49JjCcc6oGLiLSjWAoHJcWqhEVJTk0t3XwYUNLXOpwiAyU5haJY8aEAlIMlleHOG3a2HiHIyIi0id92kICYGZjgD0zZefcpphEJCKS4IKhMLMmFsXt+ZFOJBu27VYCQ5Ka5hbxk5ORxpj8TP77xfX85rn3GV+UzVVnTuX8oyfEOzQREZEe9dqFxMzONbP3gQ3Ai8BG4KkYxyUikpDCbR3s2N1KWVy3kOxNYIgkI80t4u/RZVuoa2ylpb0TB2ypb+baR1by6LIt8Q5NRESkR31po3oDcCLwnnOuAjgNeDWmUYmIJKgPG+LXQjVifGE2GWkpaqUqyUxzizi7edFaOty+5Uia2zq4edHaOEUkIiLSu74kMNqcc9uBFDNLcc69ABwV47hERBJSTX38WqhGpKQY5cU5WoEhyUxzizirqW/u17iIiEgi6EsNjHozywNeAu41s61Ae2zDEhFJTLUN3uS+rCi+tSfKi3PVSlWSmeYWcTa+KJst3SQrxhfFLzkrIiLSm76swDgPaAL+H/A0sB74VCyDEhFJVMGQv4UkjjUwACpKc9m0vYmOzu46UookPM0t4uyqM6eSnZ66z1h2eipXnTk1ThGJiIj0ri8JDACcc+3AErxCWw2xCkhEJJEF68MUZKWRm9nnJk4xUVGcS2tHp5Z7S1LT3CJ+zj96Aj/7zEwm+KvJ0lKMn356hrqQiIhIQutLAuMlIMvMJgDPAV8G7oplUCIiiSoYCifEEutydSKR5Ka5RQI4/+gJvHrNadx8QSXtnY7ivMx4hyQiInJQfUlgmHOuCfgM8Bvn3KeB6bENS0QkMdU2NMe1A0nEZCUwJLlpbpFAzj1qPGPyM1n4UlW8QxERETmoPiUwzOwk4PPAE/5YfNdOi4jESbA+TFkCJDBK8zPJzUhVAkOSleYWCSQzLZUvz6nglXXbWF0Tinc4IiIiPepLAuPbwLXA/zrnVpvZZOCF2IYlIpJ4wm0dbN/dGtcWqhFmRnlJLhu3K4EhSUlziwTzuRMmkZuRyh9e3hDvUERERHrU6187nHMv4e1VjbyvAr4Vy6BERBLR1oYWgITYQgJeHYxVW/TXUkk+mlsknsLsdD573CTuWbKRq86cmhC1fkRERPbX5y4kIiIjXU3I6/iRCFtIwKuDUb2zmdb2zniHIiLDwJfnlOOAu17bGO9QREREuqUEhohIH9WGwgAJsYUEoLw4l45Ox+adTfEORUSGgYmjc/jkzDL+/MYmGsJt8Q5HRETkAL0mMMxsTl/GRESGu6CfwEikLSQAG+NUyPPRZVuY8/PnqbjmCeb8/HkeXbYlLnFI8tHcInEtOHkyu1rauf/NTfEORURE5AB9WYHxmz6OiYgMa7WhZvKz0sjLTIxmCfFspfrosi1c+8hKttQ344At9c1c+8hKJTGkrzS3SFAzA4WcNLmYO1/ZqO1pIiKScHqchfvtzT4ClJrZd7ocKgBSYx2YiEiiqQmFGZ8g20cARuVmUJidHpcExs2L1tLc1rHPWHNbBzcvWsv5R08Y8ngkOWhukRwWfHQyX77rLZ5YWcOnjw7EOxwREZE9DrYCIwPIw0ty5Hd5NQAXxD40EZHEUhsKJ8z2kYiKOLVSralv7te4iG9Qcwszu9PMtprZqi5jo81ssZm9738d5Y+bmd1qZuvMbIWZHdPlmvn++e+b2fwu48ea2Ur/mlvNzKL2yZPIKYeXMmVMHgtf2oBzLt7hiIiI7NFjAsM596Jz7sfAic65H3d53eKce38wDzWzb5vZKjNbbWb/4o9FbQIiIhILwVA4YTqQRFSU5LKhbugTGD21WFTrRTmYKMwt7gLm7Td2DfCcc24K8Jz/HuAsYIr/WgD8Drz5BnAdcAJwPHBdZM7hn7Ogy3X7P2tESEkxLj95MmuCDby6bnu8wxEREdmjxwSGmf2n/+1/mdnj+78G+kAzmwFcjjdpmAWcY2ZTiO4EREQkqlraO9i2qyVhOpBEVJTkUhMKE95vO0esfePUQw8YSzXjqjOnDmkcklwGO7dwzr0E7Nhv+Dzgbv/7u4Hzu4zf4zyvA0VmVgacCSx2zu1wzu0EFgPz/GMFzrklzlt2cE+Xe4045x09ntL8TBa+XBXvUERERPY4WCW6P/pffxHlZ04DXnfONQGY2YvAp/EmGh/zz7kb+DtwNV0mIMDrZhaZgHwMfwLi32cx3l9K7otyvCIibG1oAUi4FRh7OpFs380R4wqG7LlvbNiBASX5mWxrbCE3M41dLe1MHJ0zZDFIUorF3GKscy4I4JwLmtkYf3wCsLnLedX+2MHGq7sZH5Ey01L50kfKuXnRWtYEG5hWNnT/voiIiPSkxwSGc+4f/tcXo/zMVcCNZlYMNAOfBJYSvQnIAcxsAd7qDSZNmhS9TyIiI0aitVCNqCje20p1qBIYT64M8tjbNXzn9MP51mlTANjd0s7Hf/l3fvzX1Tx65RxSUkZk6QDpRQznFt3p7v8J3QDGD7zxCJlXfP6ESdz2wjp+/3IVt1x0VLzDERER6b2NqpnN8WtSvGdmVWa2wcwGvJ7QObcGuAlvyebTwHKg/WAhdHebg4x398yFzrnZzrnZpaWl/YxYRASCIa845fiixEpglJd4Kx6qhqgTydbGMD/435VUBgq54mN7t5HkZqZx7VnTWFEd4qF/VB/kDiJRn1t86K/MxP+61R+vBiZ2OS8A1PQyHuhm/AAjZV5RlJPBRbMn8vjbNXv+DRQREYmnXhMYwB3ALcBc4Dhgtv91wJxzdzjnjnHOfRRvL+v7RG8CIiISdXtXYCRWDYz8rHRK8jLZOAQJDOcc//rISna3dnDLRbNIT933PyHnHTWeYw8ZxU1Pv0uouS3m8UhSi+bc4nEgUsh7PvBYl/FL/WLgJwIhf6XnIuAMMxvl1846A1jkH2s0sxP97iOXdrnXiHXZ3Ao6neOu1zbGOxQREZE+JTBCzrmnnHNbnXPbI6/BPDSyPcTMJgGfwatbEZUJyGDiEhHpSW0oTH5mGnmZBysdFB+TS3LZuK0p5s956B/VPLtmK98/cyqHjck/4LiZ8eNzj2RHUyu3PjeoZlUy/A1obmFm9wFLgKlmVm1mlwE/B043s/eB0/33AE8CVcA64PfAlQB+7awbgLf81/WRelrAFcAf/GvWA09F5+Mmr4mjczhrZhl/fn0TjWElJkVEJL76MhN/wcxuBh4BWiKDzrn/G8RzH/ZrYLQB33DO7TSznwMP+JORTcCF/rlP4tXJWAc0AV/2n7/DzCITENh3AiIiElU19c2UJdj2kYjykhyef7cups/YUt/M9X99h+MrRvOVORU9njdjQiEXHzeJu1/byCXHT+w20SHCAOcWzrlLejh0WjfnOuAbPdznTuDObsaXAjMOFsNItODkyTyxIshf3trMV0+eHO9wRERkBOtLAuME/+vsLmMO+PhAH+qcO7mbse1EaQIiIhJttQ3hhNs+ElFRkse2XdU0htvIz0qP+v07Ox1XPbicTuf45YWzei3Q+b0zDudvK2r48V/f4Z6vHI+3Gl9kH1GfW0jszJpYxAkVo/mfVzcy/yPlB2wfExERGSq9/hfIOXdqNy9NMERkRAmGwpQVJOYKjAq/kGestpH88fUPeG39dn54zvQ+tUktzsvkO6cfzsvvb2PxOx/GJCZJbppbJJ8FH53MlvpmnlwZjHcoIiIygvW6AsPM/q27cefc9dEPR0Qk8bS2d7JtV0sCbyHxWqlu2L6bmYHCqN67qm4XP3tqDR+bWsrFx03s/QLfF048hPve3MQNT7zDRw8vJSs9NapxSXLT3CL5nDp1DIeW5rLwpSrOnTVeK6tERCQu+rIGcHeXVwdwFlAew5hERBLKhw1hnIOywgRNYBT7CYy66HYiae/o5LsPLiczLZWb/qmyX7+wpKemcN2njmTzjmb+8PKAO2/L8KW5RZJJSTEuP3kyq2saWLJ+ULXcRUREBqzXFRjOuV92fW9mv8DrDCIiMiLUNiRmC9WIrPRUxhdmsXF7dBMYdeYWQQAAIABJREFUC1+uYtmmen598VGMHcD2mTmHlTDvyHHc9sJ6/unYAGUJ+vOToae5RXI6/+gJ/OKZ91j4chUfOawk3uGIiMgINJAqTDmASlCLyIhRU98MwPgEXYEBUFGay4Zt0UtgrAk28KvF73H2zDLOnTV+wPf5wdnT6HSOnz35btRik2FJc4skkJWeypc+cgh/X1vH2trGeIcjIiIjUK8JDDNbaWYr/NdqYC3w69iHJiKSGGpDkRUYiZvAKC+OXgKjtb2T7zywnMLsDG44f8ag9rpPHJ3D1045lMeX1/DmBnW6Fo/mFsnr8yccQnZ6qraGiYhIXPSljeo5Xb5vBz50zrXHKB4RkYQTDIXJy0yLSYvSaKkoySXU3MbO3a2Mys0Y1L1ufe591gQb+MOlsxk9yHsBXHHKoTy0dDPXPb6av/3zXFJ7acMqI4LmFklqVG4GF80O8Oc3N/G9M6cOaHuZiIjIQPWljeoHXV5bNMEQkZEmGGpO2AKeERV+J5KqQa7CWLZpJ7/9+zouPDbAJ6aPjUZoZGek8q9nT2NNsIH739oUlXtKctPcIrl9ZW4FHZ2Ou17bGO9QRERkhBlIDQwRkRGlNhRO6O0jsLeV6sZBJDCaWzv47gPLKSvM5kefmh6t0AA4e2YZJ1SM5heL1lLf1BrVe4vI0DqkOJd5M8Zx7+sfsKtFuScRERk6SmCIiPQiGAon/AqMiaNySE2xQdXB+I9F71K1bTc3X1BJQZS3y5gZ/37ukYSa2/jV4veiem8RGXqXnzyZhnA7D7y1Od6hiIjICKIEhojIQbS2d1K3qyXhW4BmpKUQGJXNhgG2Un1t/Tb+59WNfOkj5TFrjzitrIDPn3AIf3z9A96tbYjJM0RkaBw9aRTHl4/mjlc20N7RGe9wRERkhFACQ0TkILY2hnGOhF+BAV4djIFsIWkMt3HVgyuoKMnl6nlHxCCyvb5z+uEUZKfz48ffwTkX02eJSGxd/tHJbKlv5qlVtfEORURERgglMEREDiIZWqhGRFqp9jcxcMPf3iEYauaXF80iOyM1RtF5RuVm8N0zprKkart+6RFJcqcdMYbJJbksfKlKCUkRERkSSmDIAR5dtoU5P3+eimueYM7Pn+fRZVviHZJI3NT4CYzxRYm9hQS8FRhNrR3UNbb0+Zrn1nzIA0ur+foph3LMpFExjG6vzx0/iSPG5XPjE2tobu0YkmeKSPSlpBhfPXkyK7eEeL1qR7zDERGREUAJDNnHo8u2cO0jK9lS34wDttQ3c+0jK5XEkBGrNtQMJMcKjP62Ut25u5VrHlnJEePy+fYnpsQytH2kpngFPbfUN3P7i+uH7LkiEn2fOWYCxbkZ/P7lqniHIiIiI4ASGLKPmxetpblt37+INrd1cPOitXGKSCS+gqEwuRmp5GemxTuUXlX0s5XqDx9bRX1TK7dcdBSZabHdOrK/EycXc05lGbe/uJ7qnU1D+mwRiZ6s9FTmf6Sc59/dyvsfNsY7HBkkrcIVkUSnBIbso6a+uV/jIsNdsD5MWVE2ZhbvUHo1viibjNSUPrVS/evyGp5YEeRfPnE408cXDEF0B/rXT07DDH765Jq4PF9EouMLJx5CVnoKf3h5Q7xDkQFwzhFu6+CPr2/k6odXaBWuiCS0xP+TogypsqIsaurDB4wnw/5/kVgINoSTogMJeFszJhXn9JrA2NoQ5kePreKoiUV87aOThyi6A40vyubKjx3GLYvf47X12/jIobFp3yoisTU6N4MLj53IX97azHfPPJwx+cnxb+ZgPbpsCzcvWktNfTPji7K56sypnH/0hCF7vnOO5rYOdoXbaWxpZ1e4nV0t7TT6X3eF27z3/rG94/5YS9uea9o6ui/CGlmFO5SfS/opGISLL4a//AXGjYt3NCIxpwSG7GPOYSU8uLR6n7Hs9FSuOnNqnCISia/aUDOHjymNdxh9VlGSy8btPScwnHNc/fAKwm0d/PKiWaSlxnch3oKPTuaBpZv58ePv8MS35sY9HhEZmMvmVvCnNz7g7tc2ctWZsW3HnAgiNcMi224jqxWAXn/Z7+x0NPmJh10tbQcmFvYkG9r2S0jsl6Boaaejs/fuLxlpKeRnppGXlUZeZhr5WWlMKMomPyufvC7jPW0X1ircARjKpMINN8Arr3hfb7stts8SSQBKYMgeoaY2nluzlckluYSa29i+u5WSvAx+ePZ0Zd5lRGrr6GRrYwtlSbQCqaIklxffq6Oz05GScuC2lweWbuaFtXVc96npHFqaF4cI95WVnsoPz57O1//0D+59YxPzP1Ie75BEZADKS3I5c/o4/vT6Jq782GHkJkHdoMHoqWbYjx5bxcotob3Jhi4rIfYkJlrb6UvX2az0FPIy0ynI2ptkmJSbQ15WWpeERPqe9/n+Od57bzw3M7XPNY7+/MYmtnSTrNAq3AHoa1LBOWhrg3AYWlr2fp04ETIzoaYG1q71xrq+Pv1pyMuDv/4Vfv976OyE//kf+NGPtApDhr3h/V8X6ZdfPfse9U2t/PGy4zmkOJejfvwMF86eqOSFjFhbG1twjqTZQgJQXpxLa3snNaFmAqNy9jm2eUcT1//1HU6aXMz8k8rjE2A3zjxyLHMPK+GXz6zlU7PGMzo3I94hicgAXP7RyTy9upYHl27mS3Mq4h1OTPW0KqEx3M79b27ak3DIy0onPzONMflZ+6yA8L6m75eM2Hs8NzON9CFekXbVmVP3WVUCkGqmVbgH09gIK1dCba236qK2Fqqq4OGHvaTCHXd4iYzOzr3JiZYWePxxOOEEuOce+NKXDrzv22/DrFnwyCPwz/984PF167wExo03Qnu7N9baCtde6yUyRIYxJTAEgLW1jfzx9Q/43AmTOHJ8IQBHTSzi1XXb4hyZSPwkUwvViEgnkg3bdu+TwOjsdHzvweWYGTdfWNnt6ox4MTOu+9R05v36ZX7xzFp++umZ8Q5JRAbg2ENGMfuQUdzx6ga+cOIhw3pLWM81w7J47ZrT4hDR4EX+YBWp65GbmcaulnZmTSyK3UOHcqtFX57V0QHbtnmrH4qKoK7OS0LU1u6bpPjZz+Azn4Fly+CUU/Zen5LiXdvhJ4E6OyEUgmOP9cYzMyErC0aP9o4fcwz85CfeWORYZqa3AgPg/PNhxox9j2VmwqRJXizLl+8b+113eZ/tZz+L+o9PJFEogSE457j+b6vJy0zju6fvzbLPOayEW59/n1BTG4U56XGMUCQ+giFvcppMKzC6tlI9ecre2h13vbaRNzbs4D/+qfKAlRmJYMrYfC496RDuem0jnzt+EjMmFMY7JBEZgMs/Opmv/fEfLFr9IWdXlsU7nJiZOb7ggARGdnoq30/y+h/nHz1hTyKjrrGFuTc9z+1/X89NF1TG5oGxqN/Q0eElDtLTvS0amzd7qx5++EN4+WWYP99buTB7NuzYAV/4wt4Exdat3vX/8R9w1VXeCotrr4WCAi8xMG4cHHXU3gREZSU89RSUlXnH2tpgypS9qyLa2rx73nZb90mTmTO9V08CAe/VnRtu8D5nVykp8OyzXgLDOdi1C/Lz+/8zFElgSmAIi1bX8uq67Vx/3pGM6rJ0e+6UEn793PssqdrGvBnDdxIi0pNgfSSBkTz7f8cWZJKdnkpVl04k67bu4qan3+XjR4zhwtk9TIQSwL984nAee7uGH/91NQ987aSkaF0rIvv6xLSxVJTksvCl9Xxy5rhh+b/jf3ywk8VrtjL7kCKCoZa4dSGJtdL8TD573ETue3MT3/7ElOjXwggGve0OnZ2wcCGYeUmHlhY44gj41re8877yFa8WRGvr3i0YH/+4l2QAL2GwbdveY52d8NWverUhAA45ZN/nPvOMt8LhD3+A3FwvwTB+vLdKIpKkOPlk79zyci8JkJvb/WcoKoJ58/a+v/LKA5MKHR2xKbC5ZIn3M+mqs3Nv8uSxx+Cyy+D734dvfrPnzyCSZJTAGOHCbR3c8Lc1HDEun88dP2mfY7MCReRkpPLquu1KYMiIFAyFyclIpSAref6pNDPKS3LZ6Ccw2js6+e6Dy8nOSOXnn5mZ0L9MFGan79mD/fjyGs47avj8IiAyUqSmGJfNreCHj67irY07Ob5idLxDiqrdLe1854G3KSvM5s4vH09B1vBeobrgo5P58xub+P3LVVz3qSOje/OuKwja2+F3v/N+yc7MhE98Ym8C48MPYedObzwnx0saFBfvvc+553orHTIzISPD+3rMMd4xM7jzTvjTn+Cll7znpHf5v1lmJixd2nOMKSn9+8W/u6RCayu89lrf79FXy5Yd/HhFhVdn45pr4JZb4F//Fb72NW8rSqJTa1g5iLjMys3s/wFfBRywEvgyUAbcD4wG/g/4onOu1cwygXuAY4HtwGedcxv9+1wLXAZ0AN9yzi0a4o+S9P77xSq21Ddz3+UnHrBXNSMthRMqRqsOhoxYtQ3NjCvMSuhf+rszuSSXd4INANz+4nqWb67nvz53NGMKEn/SctHsidz7xgf87Ml3OX36WHIykid5JCKeC44NcMvi91j40vphl8D4yRPvsGlHE39ZcNKwT14ABEblcP7RE7jvzU1849TDKMnLjM6NI6svuv6yn5kJ77134C+sTzxx8Hv98pcHPz5vnrcyouu2jj//2as9Ee1fjntLKgylWbPgySe95MmPfgT/8i/wwAPw6qvxjqx3ag0rBzHk1ZXMbALwLWC2c24GkApcDNwE/Mo5NwXYiZeYwP+60zl3GPAr/zzMbLp/3ZHAPOC3Zta3PlECeD3Lf/fiOs6eWcZJhxZ3e86cw0qo2rZbPcBlRKqpDzM+ibaPRJSX5LBpRxPLN9fz6+fe55zKMs6pHB/vsPokNcX4908dSW1DmN++sD7e4YjIAGSlp3LpSYfw7JqtrNu6K97hRM3idz7kvjc387WPHjrsEjMH8/VTDqWlvZP/eXVD9G7aXf2GyFaLaBvKZyWij3wEnnsOnn/eW4UBXkeUP/1pb1InUYTD8NBD+7aGra2Nd1SSYOJVHjoNyDazNCAHCAIfBx7yj98NnO9/f57/Hv/4aeb9OfQ84H7nXItzbgOwDjh+iOIfFn765BoArv1kzwWn5hxWAqBVGDIi1YbCSdWBJGLH7lY6Oh3n3fYqHZ2OkyZ3n6BMVLPLR/Ppoyew8KUqPti+u/cLRCThfPHEQ8hMS+GOV6riHUpUbNvVwjUPr2BaWQH/7/Qp8Q5nSB02Jo+zZozjntc+oCHcFp2bDuVWi6F8ViI79VQ4+2zv+4cegi9+EaZP91ajdHQc/NpYaW/36puAl7wYMwYuvHBvYiUchu99Lz6xScIa8gSGc24L8AtgE17iIgT8A6h3zkXSgNVAZPPzBGCzf227f35x1/FurtmHmS0ws6VmtrSuri66HyhJLVm/nSdWBLnilMMO2pFg6th8SvIylMCQEae9o5OtjeGk6kAC8OiyLTzyf1v2vO908JMn1vDosi0HuSrxXHPWEaSlGj95Yk28QxGRASjOy+SCYwM8/H9bqGtsiXc4g+Kc45qHV9DY0s6vLz6KzLSRt+D3yo8dRmNLO39c8kF0brhsmdclY/9XLLZgDOWzksXnPw+PPgrZ2d73lZXw8MPezyWWOjvh7be9mhznnON1c/nc57xjWVnw3e96dUwinPOSLVqFIV3EYwvJKLzVExXAeCAXOKubUyP/C+pu87k7yPiBg84tdM7Nds7NLi0t7e6UEaW9o5Mf/3U1E4qy+dopkw967v9n7zzDoyraMHyfbHooqbSEkJBA6DXU0ESaWCiKYgEbomJFBcFPREUBRVRQQFBQQBEVqSIC0jsECb0loaURIKQQ0ne+H7OhJqRtDXNf1167OXvOzJzkZPfMO+/7PHZ2Gu2CvNkWdQlh6g81hcKKSEzLQi9sy4EEYNLq42Tl3pwqm5GTx6TVxy00otJRtZIzr3YNZu2R82w+YQg8x8dD587qRkahsBGe7xBITp6e+TtOW3ooZWLhnnP8ezSRd3vVo27Vu9OSspFvZbqE+DB76ykysi20Wq8wHpoGffrIIM5vv8nAwqRJxu9HCDh1Q+nRgAHQvLkMVERGSgvbN9+8/v758wW38fHHUutELUQrsEwJSTfglBDighAiB1gMtAfcDSUlAH6AIZ+IGKAmgOH9ykDSjdsLOEZxB37dfZZjCWm8f399nB2KXkXoEOzFhbQsTpajOlaFoijiU/ItVG0rA6MwvRpb1LF5vkMgtbxc+WjFYXLy9DeLeikUCquntk8FutevyrydZ2x20nv6Yjrj/jpCWLAXz7YPsPRwLMor9wSTlJ7Nwj1nLT0UhbGws4NHH4VDh2DxYhnYuHAB7r0X1q4tXUbGmTPS+eWpp8DXF4KCpIsMSFvXefMgJgaOHYPp06Fv3+vHFlbus2GD1O9o3BhWrSr9+SqMjwUWlywRwDgLtNU0zdWgZXEvcATYADxi2OdpYJnh9XLDzxjeXy9kKsByYKCmaU6apgUCdYDdZjoHm+VyejZfrDlB+yAvejUqnvJyvg7G1pOqjERx95BgCGDYmgZGDfeCM0YK227NONnr+OCBBkRdSOf35bvlDZES9VIobIqhnWqTfDWHP/aeK3pnKyM3T8/w3yOwt9P4YkBT7Oxsy5HK2LQK8KR1gCezNkeTfUumn8LG0emghkHsOypKZkf06CEnpps3y+2FTVQTEiAtTb6eMwcCAmSgYu1auf/MmWBvWKPu3Vtqb/gWYpNeWLnP0aOwZ4/UyOjdG155Ba5eNfqvQVEKLLC4ZAkNjF1IMc7/kBaqdsAs4F3gLU3TIpEaF7MNh8wGvAzb3wJGGdo5DPyODH78A7wihLDN8L4Zmbz2OFeychn7YMNiW0P6ebhSy8uV7VEqgKG4e4hPkRkLtuZCMqJnCC63ZFa5OOgY0TPEQiMqG13rVaFzXR8cPvkYkWWoo8/NVVkYCoWNEBrgSS1PFz5acYTAUSsJm7jeZjR5pm+MYt/ZZD7p19jmyglNxStdg4lPyWTJvhhLD0VhKtq2lXa2334rAxmdO0PPnvDhh3Ki+v77sGQJvPYaNGwI1avDMsO6c9euMHWqzOhISIBff4UXXoCKRii9atIEdu+Gt96SmRu9eples0NxO0JAYqK04129Wi4qmXlxSbvbdA1CQ0NFeHi4pYdhEY7EpfLAN1sY3C6ADx9qWKJj31tykOURcez7oDsOOkuZ1ygsydJ9sUxafZy45AxquLswomcIfZsXEkEvB4z76wgLdp3lyMc9ix3ssxbK29/q9KFI/JrWw15/PUad5+SM7vQpqFa8TDKFadE0ba8QItTS47AEd/N9RXFYui+WkYv2k513/X7TxUHHhP6Nrfpzaf+5ZPrP2M4DTaozZWBzSw/HahBC8OC3W7mSmcu6t7ugu8uzUso9GRkwY4YU3vzjD+kKko+rK3TsKIMW/ftDcLD5xrVuHeTkyCBGvoOKzgbEdePjYeBAqTti7fcvqamQlCQzagCGDYPwcBncSkmR2wIDITZWlvk4OsKQITBtmtGGUNi9hZqJ3iUIIfhwxWEquzgwvFvdEh8fFuTNlaxcDsQkm2B0Cmtn6b5YRi8+SGxyBgKITc5g9OKDNrOKVhoSUqQDia0FLwD6Nvdl26iunJp4P9tGdbXqSUJxsH/7bXT6mxPs8nJyiH51hIVGZGSUOKmiHDNp9fGbghdg/cLCV7NzGf5bBFUqOvHxQ40sPRyrQtM0XukSzOlLV/n7YLylh6MwNS4uMuOhQgW5yg4yUNC3r9S1+OcfGDnSvMELkBodvXrJ15MmQZcuN4uFWisjR8KWLTKLJd8q1hQU977ixjH89JMMQHTqJIMrlSvDY49dfz8uDtzdpWvN11/Dzz/LbfmaJdnZZsvCUAGMu4S/DsSz+1QSI3rWo7KrQ4mPbxfkhabBtshLJhidwtqZtPoYGTk3TyCt/Qa0rMSlZFDd3bb0L8orFbZuvM12ylGfR8XVKzmWkEpaZo5FxmU0lDipohxji8LCE/4+RvTFdCYPaFqqe6byTs+G1QjycWPahkjlUHc3EB8vJ6b5E9W8PFk6kJRk2XHlU6sWHDgATZvC3LnWW1Yye7ac9AshXzs4gJsbrF8v39+4Ebp1k9kszz4Lb7wBH3wgBU9BiqOuWiVLNw4dgrNnITn5emDpRgq6r9izB6ZMkfohPXrIzIr87AqA5cvhr7/k6/vvh4kTYezY6+8vXQpr1sgMizfekOO49Xedl2eWexn7ondRFIatpGlfzc5lwt9HaVijEo+1qln0AQXg6eZIwxqV2Bp5kdfvrWPkESqsFSEEW05eJDY5s8D3rfkGtKwkpGTSPsjb0sNQAC1e/ZmApDiivfyubft6xSQeOLqFF0b+QESNECo52+Pn4Yqvhwu+7i74eciHr7vc5uHqUOxsGrN+tp87d3P96Jgx1p9WaqVomjYcGIK0VD8IPAtUBxYCnkjtrUFCiGxN05yAeUBL4BLwmBDitKGd0cDzQB7wuhBitZlPpVxRw92F2AK+K6pWss4A8YbjiczfeYYhHQJpH6y+AwrCzk5jWJdg3v5jP+uPJXJv/aqWHpLClIwbd/skOX+iasRygVLz+OPQvj0MHgzPPCMn4d99B15elhuTXg+bNslARYcO8NJL0mFFp5O/O50OWrSQ2Q61asljcnJkyc7587JEIzVVPvr3Bz8/+PtvWcZxK8ePQ926MGuWzIxwdob9++UYZsyAd98Ff38ZPJk6VWZW1K0rx1W3rgxCaBr8/vt1sdXiUJhjzPbtpf+9FRMVwCgl+Sn1+avS+Sn1gNUFMb7bGEVcSiZTHm9eplrFsCBv5mw7xdXsXFwd1aVTnhFCsP5YIlPXR7L/XDJ2GugLCGjborNFccjN05OYlmVzFqrljpgYcHCguocb0ZrfTW990P1l2sQe5ZeN3/DrzGWcybIj5vJVzlxKZ3vkRdJvsWx0ddTh6+6C7y2BDV93F2p6uOBdwQk7O838n+333w/54qTWdENoY2ia5gu8DjQQQmRomvY7MBDoDXwlhFioadp3yMDEDMPzZSFEsKZpA4HPgMc0TWtgOK4hUAP4V9O0ukokvPSM6Bly0/9UPtl5eURfuEJtnwoWGtntJKVnM3LRAUKqVuQdGxU+NhcPNavBl2tP8O2GSLrWq2KT5ZaKYmLBiWqxqVVLZjJMnizFRk+cgHbtzD+O2FhZijFnDkRHy2BBkyYyi+WXX67rdeTlySyK5cuvL1p07y4fN3Jj4OiRR6B5cxnUuDHAkX981arQqJH8e+VnRmgafPSRDKSMHi1LV7y95fZbKUnwAqRjjIVQs9BSMmn18UJT6q0pgHEu6SrfbY6mT7MatArwLFNbYcHezNwcze5TSXQJqWKkESqsCb1esOZIAt+sj+RwXCp+Hi6M79cYR53GmGWHb7vma/u4kacX5U7E68KVLPL0QpWQWBIh4Lnn4MQJRv6+kVErbi5jyqlYmcjJM+g4dABDFk2RX87XDhWkZOQQczmDmMsZxCZnEHP5KrGG1xHnkkm+enPZiaPOjhruzsSnZJJ1iz2gyT7bv/4aDh68/nN2trzpUVkYpcUecNE0LQdwBeKBrsAThvfnAh8iAxh9DK9BOqN9a7B27wMsFEJkAacMDmitgR1mOodyR/7/zY1ZTY+28mPe9jM8PGM7PzwdSstaZbs/MQZCCEYvPkDK1RzmPtsaZwcbEAS0IA46O17qXJsxyw6zMzqJdkEWXO1WmBYLTlRLhE4nNSaefRZ8fOS2JUukVoaLCRfc9HqwM6gyDB4sAyn33CMDB/37S7HTYcNKl8Vid4Pag4/P9fMqiD59oHVrqF37egBDr5dOMJ9+Wq7uK1QAo5TYSk3nJyuPYG+nMfq++mVuq1WAJ446O7ZFXlQBjHJGnl6w8mA809ZHcvx8GoHebkx6pAl9m/tec52x19lduwGt7u5MnSoV2HTiIkPnhTP18ea4OZWfj5P4FFkyozIwLMjcudJDfto0+rQOQDg43FbW0bG5L5x+T6qi33ADoWka7q6OuLs60si3coHNX8nKNQQ0ZGAj5nIGMckZnL5UsK+80T/bd+2Ct9+WqyA31pBmZ8PHH0uLOEWxEULEapr2BXAWyADWAHuBZCFEvkpZDJAfhfIFzhmOzdU0LQVp4e4L7Lyh6RuPUZSSvs19bwsA9m3my9NzdvPE97uYMrA5vRpZ9uZ60d4YVh8+z+j76tGgRiWLjsVWGBBakynrIpm2IVIFMBTWQ/4k/8QJePhhqF9fZj80a2bcfg4flosnCxfKIE/VqjIDpGJFCAq6eV9zZbFYe7mPkSg/Mw4zU1hNpzVNeLaevMjqw+cZ0TOEakYYl4ujjha13JWQZzkiN0/Psog4pm2MJPpCOnWqVGDKwGY80KTGbVkVBd2Azt95hrHLDjHgux3MfiaU6pVtsKSkAEurBEMAo1olGzyf8kBCAgwffr1ulIKvP0BO9kuRulzByZ6QahUJqXazN33E2fUFfrYbtVwqLg769ZPpmrfe0Oj1MqVUBTBKhKZpHsjsiUAgGfgDuK+AXfOjRQVdNOIO22/tbygwFMDf378UI1bU8nLjz5fbM2ReOC//spcPH2zI0+0DLDKWc0lX+WjFEdoEejKkY22LjMEWcXbQ8ULHQCasOkbEuWSa1XS39JAUiuvUrStdUp55RmYmfPqpdFQpi93qlSsyo2H2bLkQ4eAADz0kt1etWniQxFxZLLZQ7mMElAtJKRnRMwSXAtILXR11pFy1vCJ+Tp6ej1Ycxt/Tlec7BBqt3Q7B3hyJT+XSlSyjtakwP9m5ehbuPkvXyZt4+4/9ONnrmP5kC1a/2Yk+zXwLLwm5xZZpUNtazHmmFWeTrtJ32jYOxaaY8SyMRAFKzfmr7TVsuYTElq05X31VCln98MPN6ZMFkR+82LpVlpwUpMZdAgr6bHfU2THCmPXw6elQvbr0Uxfi+iMvDx7G+RnKAAAgAElEQVR4QAp47VAVCyWkG3BKCHFBCJEDLAbaA+6apuUv1vgBcYbXMUBNAMP7lYGkG7cXcMw1hBCzhBChQohQnzul9CruiFcFJxYMaUu3+lUZu/ww4/8+ir4gwSUTkqcXDP8tAg2Y/GjTclcSaWqebFuLyi4OTN8QaemhKBS306OHLNV86CFZXvLQQyV3KRFCWsaCdF558UUZsPjyS6l5sWjR7RkXlmLfvpvvK/IftlIGVExUAKOU9G3uy4T+jfF1d0EDfN1deLJtTc4mZdBvxjbOXEq36Pjm7zjDycQrjHmggVHrOPMVuXdEqywMWyQzJ4/5O05zzxcbGbX4IO6uDnw/OJS/X+9A78bVsSvqxq2AyX6XkCoserkdOk1jwHc7+PfIedOehDGJj5eaA/kOEIbJfkJKJs4OdlR2sWH7PFu15szKkpkJY8dCSAmCBkePyr/hlCll6v7Wz3Z7O40Kzjp6NjRCenv+jUSdOjJ40bjxze/b2cG8eVCzprQ5s1YrOOvkLNBW0zRXg5bFvcARYAPwiGGfp4FlhtfLDT9jeH+9kH6Qy4GBmqY5aZoWCNQBdpvpHO5KXBx1fPdUSwa3q8WszdG8vnAfWbnm00yduTmK8DOX+ahPQ/w8XM3Wb3mhgpM9z7QPYM2R8xxPSLP0cBSK2/Hygj/+kOKa/fvfXrpZGPHx0ko0JASeekpu8/eHI0dkUGT48DtrUihMhna3+TeHhoaK8PBwk7W/+1QSL86X7X8/OJTQMgpnloZLV7Lo8sVGmvt7MPfZVkZVhs7N09P847U80LQ6E/o3MVq7CtOSkZ3Hr7vPMnNzFOdTs2hZy4PXugbTua5P8a+P+HgpDJSZKcWQoqNvEgRKTM1kyLxwDsam8P79DXguLMD6VcmfeUZqLYCcNA8dCtOm8cqC/zgSl8qGd7pYcnSlJzYWAgOlJVcBfyubIN/WqyT79+snPdJ375Z+8EZgR9QlHv9+Jy91DmLUffXK1tg338DevdLqzNGx8P0OHQJ3d2mbZiNomrZXCBFq4TF8BDwG5AL7kJaqvly3Ud0HPCWEyNI0zRmYDzRHZl4MFEJEG9r5H/CcoZ03hRCr7tSvqe8r7haEEMzaHM2EVcdoE+jJrEGhVHY1bRD5UGwK/aZvo0eDanz7RHPr/86yUi6nZxP22Xp6NKjK1wObW3o4CkXR/PwzrFwpyzUzM28uJV63Topsr1olMyM7dYIXXrgexFCYjcLuLVQGhpFpHejJkmFhuLs68sT3u1gWEWv2MXyx5jgZ2Xl88EADo38Z2+vsaBvkxdbIi0ZtV2Ea0rNymbkpio6fr+fjv44Q6O3GgiFtWPRSO7qElND2bNy463V1+YJAN1ClkjO/DW1HjwZVGffXET5YdpjcvLKl85uU+HhYsOD6z7m5sqYxIYH45Ayr0rMpEULAfffJ4AUU+LeyWiZNkisbUHJdC02TJSeenvDkk7IExQi0C/JiQEs/vt8SzdH41NI3tH69XK1JTi7aqqxRIxm80Oth48bS93mXIYQYK4SoJ4RoJIQYJITIEkJECyFaCyGChRADDO4iCCEyDT8HG96PvqGdT4UQQUKIkKKCFwrjoWkaL3YOYsrAZuw7m8wj320n5nLBorrGIDMnjzd/i8DD1ZFP+zVSwYsy4OHmyJNt/Fm+P46zhQghKxRWxcWLsvSjSRNZErJli8z8BNizRy42jBwphUA3bVLBCytDBTBMQIC3G0uGtae5vztvLIxgyr8nMVemy8GYFBbuOccz7QMIrmIab/WwIC/OJWWoLykrJjUzh2/Xn6TDZ+uZsOoY9atX4vcX27FwaDvaB3uX/EYtPl6m5+frC2Rn31RykY+Lo44ZT7bkxU61mb/zDEPmhZOWaXlNmAIZN+72SXJWFnz0EQkpmUYRvrUI779/uzVnAX8rq2PtWnmz8PPPpW/D21umiOYrgxuJ93rXp7KLA6MWHySvNPX5p07BgAEyDXX+/KJ1PfKZOhW6dpUiZArFXUKfZr7Mfa41CamZ9J++ncNxptFWmrjqGJGJV/hiQFPcXe+QEaUoFkM61sbezo7vNkdZeigKRdG8+abUmnJyghUr5OLPTz/Je6XXX4ezZ2H8eFnyqbA6VADDRLi7OjL/+Tb0b+HLV/+e4O3f95u8plMIwYcrDuPl5sjr3Uz3D9ehjtTB2BalsjAszdJ9sYRNXE/gqJWETVzPgl1n+HLtCTpMXM8Xa07Q3N+DJcPaM//5NrQOLEM5U0G2TFlZ0gHiFuzsNEb3rs+E/o3ZcvIiA77bUaCrg0UZOxbWrLldqRkQO3ZyPi3LdjMw9u69fYJs7VkY6emyfKduXRgzpmxt9ewpsx2GDTPO2JCrix880ID955L5eeeZkh185Qr07Sv/f5Ytk/ZqxWXoUKmT8eSTcKaE/SoUNky7IC/+fLk99nYaj363g80nLhi1/S0nL/DT9tM80z6ATnVVDbsxqFrJmQGhfiwKj7nm5KVQWDWhoXDPPTe7kowbB66uRWdKKiyKCmCYEEd7OyYPaMrb3euyeF8sg37YzeX02ydMxmJZRBx7z1xmZK96VHI2Xd1okE8FqlZyUmUkFmbpvlhGLz5IbHIGAohNzuC9JYeYuu4k7YK8+Ou1Dsx5phXN/T3K3llBtkx6PSxdWughj7f256dnWxF7OYO+07ZxICa57OMwBtOny8DLAw8UqNR8ftMO2kX9Rw03GxPwzFfIPn/+9mBTdjb89ZcMZFgj778Pp0/LEhAXI9iV3nOPDOLExck0USPQp1kNOtbxZtLq4yW7OT96FGJiZG1tcHDJOnV1hT//lOVNjzwig4YKxV1C3aoVWfJKGP5ebjz30x7+CD9nlHaTr2bzzh/7Ca5Soey6NoqbeLFTEHlC8MOW6KJ3VigsTXy8zPrMvzeylYxVhQpgmBpN03jt3jpMGdiMiJhk+k3fRvSFK0bv50pWLuP/PkpTv8o80sK0wm+aphEW5M2OqEtmtztTXOezf46RkXP7hLRKRSdmDgqlkW9l43V2qy2TXg9vvy0FkO5Axzo+/DmsPY46Ox6duYN/Dln4S+Hvv+G112TwYvLkAndJ3r6bn38fQ5cpY23HBWLXLinauWxZwRZaq1fLdEhrdLbYvVs6hwwbBh07Gq/djAxo1Qqef94o56xpGp/0bUROnp6xyw8V/8BWrWQJSY8epes4OFimtYaHy/85heIuomolZ35/sS1ta3sxYtEBpq4rW0muEIL/LT3EpSvZfP1YM6O6tCnA38uVh5rW4JddZ026YKdQGIWCsoutPWNVAagAhtno08yXX19oQ2pmLv1nbGeXkW1Ip22IJDEti7EPNSzaCtMIhAV7k5SezdGEMojaKUpEYlomfx2IY8zSQ/T8ajPxhawCX0gzwyqtpsEXX0Bzg9r42bOF7lq3akWWvhJGvWqVePmXvczaHGU2TZibiIiAxx6T7hS//npzyuANnPKrwzftHsN30S8wYYKZB1kKjh+H+++XNmFt2xa8T48eMHo0zJx5XaTKWmjUCD780Pi/axcXeOcdWL5cun4YgVpebrzRrQ6rD59n9eEignErVsggmRBQqVLZOu7XT1q5PfFE2dpRKGyQis4OzHmmFf1b+PLl2hOMXnyQnFIKRC+LiGPlgXiGd69r3CC/4hrDugSRkZPHj9tOWXooCsWdKSi7ODsbtm+3zHgUxUYFMMxIy1qeLBnWHi83R56avYs/98YYpd3TF9OZveUUD7fwo4UxygWKQViw1MHYHmncQIziOnHJGSzZF8PoxQfo+sVGWn+6jlcX7OPP/2KoUsmJSs4F1+fVcDdCCn5J+OYbaNBAai8Ugk9FJxYObUvvRtUZ//cx/rf0UKlvQEvN/Png4SFLKSoULnAbl5LJ5I5PkTXwCfjf/8omKmlq4uKk5oNOJ7MsqlYtfN9PP5XZCOPGyb+ZNaDXyzKJDz4o+yS/IN54A7p3l+4fx44ZpckXOtamXrWKjF12uHCB2iNHpG7FwoUF6qyUinffhfbt5ev0dOO0qVDYCPklua93DWbhnnO8MC+c9KzcErURm5zBmGWHCK3lwUudg0w0UkWdqhXp2bAqP20/bb0i3goFFJyxKoTcrigWt2rxLd1nHvdNFcAwM7W83Fj8chitAjx5+4/9fLnmeJlXoz9ZeQRHezve7RVipFEWTbXKzgT5uCkdDCMhhODMpXR+33OOt3/fT4fP1tN+4nqG/7afvw7EE+jtxnu967H0lTAOjO3B/Ofb8HGfRrjckv7q4qBjRE/zXQeArM339pZZAKcKX3FxdtDxzePNGdYliAW7zvLcT3tINefNzRdfyFKLGjXuuFtCSgZODjocf5ojtRSeew6irbCe9+pV6N1bajz8/XfR+gqaBt99JwUlR4yAWPNbPN/EwYPQsCHs32+6PuzsZPmFq6sMKBghmOCgs2NC/8acT8tk8poTt+9w+TL06SP7XLJEKpwbk4kTpfBYWppx21UorBxN03irR8g1gejHZu0gMa14ejR6veDt3yPQ6wVfPtoMnRkyVe9mhnUJJjUzl192FZ6dqVAobJuCtPhGLz5oliCGCmBYgMquDvz0bGseDfVj6vpI3lgYQWYBWgbFYcPxRP49mshrXYOpUsm8rgkdgr3ZfSqJ7Fwzr6SXA4QQRCam8fPOM7z+6z7aTVhP50kbGfnnATYcT6RRjcqMfbABK1/vQMQHPZj9TCuGdgqiWU137HXy37Zvc18m9G+Mr7sLGuDr7sKE/o3p29zXvCdTvTqsWiUnh7163VE00c5OY2Svenz+SBN2RF3ikRnbOZdkQjve3FyprRAZKSfw1asXeUh8SibVKzujOTnB4sUwdy7Urm26MZYWFxfo31+OsWXL4h1jby/LZzZuBF8zXyc3kpcns0EuXTL9OGrUgO+/lw4nRhLBbO7vwaC2tZi74zQR524Qp83Lg8cfl44hf/4JfibQI2rXDk6eNJq2h0Jhazze2p8fBocSlZhO/+nbiUwsWlfsh63R7IxOYuyDDfH3cjXDKO9umtZ0p2Mdb37YcqrU97cKhcK6mbT6+G1afBk5eUxafdzkfWsWqUW3IKGhoSI8PNzSwwDkJHbGpig+/+c4LWt5MGtQS7wqFH+1LjtXT6+vNwPwz5udcLQ3bzxq9eEEXpy/l9+GtqVNbS+z9m1r6PWCYwlp7D51iV2nkth9KolLBoGrKhWdaFPbi9aBnrQN9CS4SgU0zQZXh7Ztg3vvlavDmzffbuV5C9ujLvLS/L042tvx/eBQ47il3IgQ8PLLUvdhzhx49tliHfbIjO046Oz4degtehJ79sjJsCUn/iAnybGx4O9f9rZ++02Kf7ZuXfa2SsKXX0pByoULpS6JDZKWmUO3Lzfh6ebE8lfDcNDZycBQ167ymnvhBdN1/vnnsqTk669lmYwVoGnaXiFEqKXHYQms6b7ibuJATDLP/bSHnDzBD0+H0iqgYKvwo/Gp9Pl2G11CfJg5qKVtfr/aIDujLzFw1k4+7tOQwe0CLD0chUJhZAJHraSgKIIGnJp4v1H6KOzeQmVgWBBN0xjWJZhpT7TgUGwK/Yq5kpDP3O2nib6YzpgHG5g9eAHQtrYXdhpsU2Ukt5Gbp2f/uWS+3xzNkLl7aPbxGnpP3cKHK45wICaFziE+fPZwYza+04Vd793LN483Z1DbWtSpWtF2b67CwmDBAunyUUTwAqB9kDeLh4Xh6mjPwFk7+ftgvHHHM3mynEi++26xgxdwPQPjJq5ehQcflGUylkzdF0JOWFu0kPZfZSErS9qX9u4trT7NRVSU7Pehh+DRR83XL0jB0759r1vOloGKzg589FAjjsanMnuroXSqSxc4dMi0wQuQJUB9+kiRUiU2prhLaeLnzuKXw/Byc+TJH3YV+B2SmZPH8N8iqOTiwIT+jW33+9UGaRPoSctaHszcFG1+zSuFQmFyCtPcM4cWnwpgWAH3N6nOwqFtuZqdS//p29hejIBAYlomU9adpGu9KtwTUsUMo7ydyi4ONPFzZ1uUEvLMztUTfjqJaRsiGTxnN00/WkOfadv49O+jRF1Ip3fj6nz5aFO2vnsP20Z15ctHm/FYK38CvN3K1w1V//7XV9SPHSsyxT24SgWWDGtPI9/KDPvlP2ZsNJJDyZ9/yknegAEwfnyxD8vTC86nZlLt1gCGq6ssJTl0SGp+5FhImGz8eJg2DZ55pljlMHfEyQn++UeWlfTsCefOGWWIRTJ9Ojg4yGdzX/spKVLEddgwo5Rf9GpUje4NqrJ2/kouLFomNzZoUOZ2i0TTpLZHSAicPm36/hQKK8Xfy5U/X25PY9/KvLLgv+vBRAOT1xznWEIakx5pUqIMV0XZ0TSNV+4JIjY5g2URcZYejkKhMDJPtb09E9hcWnyqhMSKOJd0led+2sOpi+mM79+YR0NrFrrvO3/sZ1lELGuGdybQ282Mo7yZSauP8d2maCI+6E5FZweLjcPcZObk8d/Zy+w+lcSu6CT2nbtMZo5cYahbtQJtAmVJSJtAT7Nrk1gF//0nLT0//hhGjSpy98ycPEYuOsDy/XG0DfTk7OWrxCdnUsPdhRE9Q0qm6yGEFN/MzoZ166RWRDFJTM2k9fh1jOvbiEFta92+w+zZMGSIFPb84QfzTsDnzJG6B08+CfPmFSvLpVhEREDnzrI0ZssWacdqSvR6Gdwyx0S/ID75BMaMka40Tz1V5uYSTpxGtGqFztERn3NRaM5m/H/PzZUBKCtAlZBY533F3UJ+psWqQwl0ruvNycQrxCVLgc/2QZ4seKGdhUd4dyKEoPfUrWTl5rF2eGclnqpQlBOEEAyes5s9py7h4eZEQkop79mLoLB7C+u481EAUNPTlT+HteeVX/5j5KIDnL6Yzjs9QrC75QN/39nLLNobw0udgywavABppzptQxS7opPo1uAOFo42TnpWLnvPXGbXqUvsPpXE/nMpZOfp0TRoUL0ST7SuRetAT1oHeuLp5mjp4VqeZs1kpsLo0XJiPGjQHXd3dtAxZWAzsnJyWX0k8dr2fEVjoPgfiJomXTkyMkoUvABpoQpQvbCg0/PPS4HGceOgWzcp2GgONm2CoUOhRw8ZyDBW8ALk32r5cpmF8ccf8NJLxmv7RhIS5HO1apYLXoC8Jv/5B155RZY9BQaWvq3sbKo9P4jcrCv06f8ZQ49dok8zM2qk5AcvfvlFXpfvvWe+vhUKK8LZQce3T7Tg2R93s+nEzVms/51NZum+WPMLXCuuZWG8umAfqw8n0LtxGTMHFQqFVbDx+AW2nLzImAca8HyHMtxHlRIVwLAyKjk7MOeZVnyw7DDTN0Zx5tJVJj/aFGeDXaZeL/hwxRGqVHTi1a5F2CaagRb+HjjZ27Et6mK5CmCkZOQQfjqJXafk41BsCnl6gc5Oo7FvZZ7tEGCo7/Skssvdk3lSbOzs4Mcf5aT1uedkuUO3bnc8RNM0DsXdri+Rr2hc5M3n5cvwv/9Jm8lKlWTZRwlJSMkAuL2E5EY++gjq1DGvfkPr1rIk5n//A0cTBMg6d4bDhyEoyPhtg8yKefFF2LtXOsKYM0vhVnQ6+PlnaNpUZmPMnl36tl5/HbZuxW7Br9hf8uPjFUfoXNcHd1czBzHXr5eBrWbNpKaJQnEXorPTiLqQftv2zBx98b5DFCbhvkbVqe19gmkbIrmvUbXyVTarUNyF5OTpGbfyCIHebgVnK5sBswcwNE0LAX67YVNt4ANgnmF7AHAaeFQIcVmTn3RTgN7AVeAZIcR/hraeBt43tPOJEGKuOc7B1Djo7BjfrxGB3q5MWHWM2OQM+rfwZeamaGKT5QTryTY1qeBk+fiTs4OO1oGeVi/kuXRfLJNWHycuOaPAFKdLV7LYczqJndHSIeRoQipCgKPOjmY13RnWJYjWgZ608PfAzQp+7zaBkxMsWQIdO0ptjP37i1ztjjNc38Xdfo3sbHj4YemEMmiQtJosBfGGDIw7ChBp2vWMkrg4iI6GDh1K1V+RREaCtze4u8OECabpI5/84MW+fVJf4auvjJfp8ccfMstj0iTLBi/yCQiAf/+Fxo1L38a//0qR2FGjsHt8IBPiUnnw261M+PsYnz3SxGhDLRbffivLtp56Sj4HBJi3f4XCSij1d4jCZOjsNF7qEsTIRQfYdOICXSyk26ZQKIzDLzvPEH0hne8Hh1rERAIsEMAQQhwHmgFomqYDYoElwChgnRBioqZpoww/vwvcB9QxPNoAM4A2mqZ5AmOBUEAAezVNWy6EKLu8vBWgaRpDOwXh7+nGqwv2sv9c8k1WNYv/i6VVgJdVrCiEBXszcdUxEtMyqVLRCiYnt7B0XyyjFx+85lUcm5zBqD8PsPfsZfR6we5TSZw0uL84O9jRspYHb95blza1PWlW0/1a9ouiFFSuLMs5fv65WJOqGu4u14J0N3KbK8iNCCFdHzZskP2UMngBMoDhaG+Hh2sxs2qGDpWWsVu3QhMjT1pjY6UlZ716sGaNcdu+E+vWwdSpMlDz1Vdl1/m4dAlefVXa6775pnHGaAxatZLPaWkyEBVSQtGpe++VgZl+/QBoUKMSQzoEMnNzNP1b+JrXWtrFBRYtgpYtZenW1q3WEShSKMxMYd8h5lDFVxRO32a+fL1WZmGoAIZCYbukXM3h63UnCQv2olt9y/0vW9qF5F4gSghxBugD5GdQzAX6Gl73AeYJyU7AXdO06kBPYK0QIskQtFgL9DLv8E1Pr0bV8HB1us1nN8OQEmkNhAV5A7A90jrdSCatPn4teJFPZq6e+TvOsCwiDl8PF0b2CuHPl9tzYGxPfhnSlje61aFtbS8VvDAGfn5SyFPTZLbCHSwsR/QMwaWA37l3RUfy9IUIDo8bJ0UtP/pIClyWgXwL1WKnuH73nSxX6d0bYmLK1PdNXL4MvXpBcjJ89pnx2i0Ob78tAw1TpshynLIyfLg8n9mzrUZw8iYeeggeeACuFNPC+uxZaceqaTJYoLt+vb7RrQ5+Hi6MXnKQrNy8OzRiAoKCpFPO3r0y20WhuAsp6DvEXKr4isJxtLdjaKfa7Dktxc8VCoVtMmXdSVIzcnj//gYWLQezdABjIPCr4XVVIUQ8gOE5P6zjC9zo7xdj2FbY9nLHxStZBW63lpTIBjUq4e7qwFYrLSMp7PekAREfdOenZ1szrEswLWt5WCwV6q4gMxO6dIE+feTrAujb3JcJ/Rvj6+6CBvi6u9C3WQ0OxKTywbJDt1uspqTINP6nn5bOEmUkISXjztket+LnJzNMUlNlECMlpcxjICND/o6OH5clOM2bl73NkqBpMHmyDAa99550WyktubnScnb0aONnqBiLDz+EqCgZaCmKq1ehb18pppqdfdvbro72fNK3EdEX0pm+Icr4Yy2KPn2kq4w59VkUCiuioO+QCf0bW0W26t3OY6388XJzZNqGSEsPRWHlLN0XS9jE9QSOWknYxPUs3Rdr6SEpgOgLV5i34zSPtapJ/eqVLDoWiy2HaZrmCDwEjC5q1wK2iTtsL6ivocBQAH//2z1rrR1rT4nU2Wm0D/Jie+RFhBBWJ9B0p9+fvU4FLMyGszN8/rl07hg8GBYuLFBjoW9z39tuNqtWdmbmpmh8KjrxZre619+oXBl27wYfH6NYmsYlZ9I60LNkBzVpAn/+KQMYo0bBjBllG8Q770g7019/lWUKliBfhDUpCZYtk+4rpfn92tvL89DrjT9GY9G5M7z7rsw26d37WknIbQghLXQjImDFikLFVLuEVOGhpjWYsTGKB5vWILhKBRMOvgCaNpXP4eHyf65RI/P2r1BYmIK+QxSWx8VRx/MdA/n8n+McjEmhsV9lSw9JYYUUVPZdYjc6hUkY//dRnB10vNXd8hltlpy93Qf8J4Q4b/j5vKE0BMNzvpdiDFDzhuP8gLg7bL8NIcQsIUSoECLUx8fHiKdgHmwhJbJ9kDdxKZmcuni7ArilGdEzhFutx63t93fXMHCgFHL84w9ZqlBMRvWqxyMt/fj635P8vPOMzE4YM0ZOjH19jeLModcLzqdm3tmBpDC6d5cT/fHjyzwORo+WJTEDB5a9rbLg4CB1FRYvlsGLW7NfimLqVDhyRL42pu2rKfjoI2jRQgYo4gr8GpHX7a+/wqefwv3337G5MQ80wNnBjveWHERfWOmTKcnJgQEDpHhuaqr5+1coFIoCeKptLSo62zN9o8rCUBRMQWXf+W50CsuxLfIi/x5NZNg9QfhUdLL0cCwawHic6+UjAMuBpw2vnwaW3bB9sCZpC6QYSkxWAz00TfPQNM0D6GHYVu6whZTIDsFSB8Ma3UhCqlVEL6Cis73V/v7uKt5+W9pPfv01zJ9frEM0TWNi/8bcW68KX/26jfRuPWXpSEKC0YZ1MT2LXL2gRmkCGCBX7z08ZHnMokUlP37VKsjLk2Up+S4nlsbVVQYyEhNlNsi+fcU7butWqaPx/femHZ+xcHSEBQugTZuCs0U2b5bZNY89Jp+LwKeiE+/1rs/uU0n8sfdckfsbHQcHGQSLjpY2xiUNPikUCoUJqOTswNPtAvjncAKRibfbpisUyknI+sjTC8b9dQQ/DxeeC7uzm6C5sEgAQ9M0V6A7sPiGzROB7pqmnTS8l68e9zcQDUQC3wPDAIQQScA4YI/h8bFhW7mkb3Nfto3qyqmJ97NtVFerm3zX8nLF192FbVYo5DltQyQVnOzZOtJ6f393FZoGX34py0n69y/2YfY6O77tV58FKyagS4jnwPT5UKOG0YYVnyx1OapVLmNp1tSpcvX7xx+Lf8ysWTIAMnNm2fo2FdnZ0tK1Vy/5fCcyM2Umg7+/FFi1FUJCpJ6Jn9/t77VuLTN+Zs8udinNo6E1aR3gyacrj3IhrWAdI5PSsaMsi/nzT+kmo1AoFFbAcx0CcbbXMWNjtKWHorBCKrsU7AJnLWXzdyO/h5/jWEIao++rbzXmBhYJYAghrraRoeQAACAASURBVAohvIQQKTdsuySEuFcIUcfwnGTYLoQQrwghgoQQjYUQ4TccM0cIEWx4lGC2oDA2mqYRFuzF9qiLhbtFWIDoC1dYeTCeQe1qUbm41pgK06PTwYgR4OYmbSz/+6/oY/R6XF54jrqnD/P5k//jiYNwKNYIopkG4lNkAKNEIp4FMXy4LCkZOrR49qfLlsHLL8sAxgsvlK1vU+HnJ88lL08KWMbHF77vuHGyxGfWLKhgZv0HY5CYKHUw1q2DsDB5Ls7OsszEza3YzdjZaYzv34jMHD3j/jpiwgHfgbfflucycmTxs2cUCoXChHi6OfJ4a3+WRsRyLumqpYejsCL2nE4iNTPntrJvB52myr4tRFpmDpPXHKdVgAe9G1ez9HCuYeWFyQpbIizYm9TMXA7HGW9SWVZmbIzCyd6O5ztYR8qTogBefFGWJxw+fOf9DhyA5cvRPv+coVNGUtnFgWd+3M1pI+muJKTI9MRSaWDcSL52RMOG8PDDUvSxMLZtk1oXrVrB77/LY62VevVkhkJi4nWL11vZv1/avj7zjAx02CKaBjt3yiya7duhXTupKVEKgqtU5OUuQSzfH8fG44lFH2BsNE1mAo0fD40bm79/hUKhKIAXOgVip8GszSoLQyGJuXyVl+bvJcDLjU/6NrpWNu+os8PZ3o6eDa1n8nw3MW1DFBevZFvcNvVWVABDYTTaB0kdDGuxU425fJUl+2IZ2Mof7wqWF5xRFMKECeDiAvfdB7F3sMpq1gwOHYK336ZaZWfmPteaPL1g8JzdJKYVbMtaEuJTMnHU2eHlVnZBUCpVgpUrwd1d6lkUpKuQmSk1Ffz94a+/SrS6bzFat5bWrnp9weKQdevC++9LG1ZbxcdHjv/yZfnzlStwqfSlccPuCaK2jxtjlh0iIzuv6AOMTeXKMgPD3h4uXICYGOm8YkT9GIVCoSgJ1Su78HALP34LP2eU72+FbZOelcuQueFk5+n5/ulQnmhT61rZ/M9D2pCWlceP209Zeph3HeeSrjJn6yn6t/ClaU13Sw/nJlQAQ2E0fCo6Ua9aRasR8py5KRpNgxc717b0UBR3olYtubKfnCzLKFJuyeBZs+a62Gdw8DUNguAqFfjx2dZcSMvi6Tl7SM0s3Sp5PvEp0oHEaBFmX18pzPn77wW7cDg7SzeW1avB29s4fZqD7t1lVom/vwxk5ObK7Xq9DER9+CF4ltCK1trYulWWOYG83sqg5eFkr2N8v8acS8rg63UnjDTAUpCYKC1W+/SR52dL+iQKhaLc8VLnIHLz9MzeoiamdzN6veCt3yM4cT6Nb59oQZDPzaWnrQM96VqvCjM2RpF8NdtCo7w7mbjqGDo7jZE961l6KLehAhgKoxIW7M2e05fJzLHASuMNJKZm8lv4OR5p6Uf1sooyKkxPs2ZSbPDIERg2TGosdO4M69fDI4/IFfEC0vib1XTnu0EtOXk+jaHzwst03SWklNJC9U40agT160sXiJ9/hjNnpK5Cvlhnu3YQEGDcPs2BTicDFoMGyUerVvI8i6NlYu3Ex8uyizzDtZSdLX8uQ8ZC29pePBZakx+2nLJciV2VKtC1q9TC0OvLfE4KhUJRFgK83Wjm586szdEEjlpJ2MT1LN13hyxMRbnkq39PsPrwed7rXZ/OdX0K3GdEzxCuZOUyY1OUmUdnXJbuiyVs4nqbuN73nE5i5cF4Xuxc2/j3xkZABTAURiUs2IvsXD17z1y26Di+3xJNbp6elzoHWXQcihLQvbvMVhg/Xq4Ob9kCDz0EFSvKEotC9CE61/XhiwFN2RmdxJsLI0otIhuXklF6C9Wi2LlTTvS7d5e6CsOGwdmzpunLXNjZQZ06sHAhhIfD6dNQvbqlR1V2xo27veQnL6/MGQuje9fDw9WB9xYftJzQcb4tLhjlnBQKhaK0LN0Xy+H4VAQggNjkDEYvPmjVkzqFcVmxP45v1kfyaKjfHbXq6levRN9mvvy07TTxKbZpp7p0XyyjFx8kNjnD6q93vcE2tVolZ4Z2ss4sdhXAUBiV1oFe2NtpFi0juZyezS+7ztKnmS+1vGxAV0BxnX79wNFRrg4LAenpMHduwdaWN9C3uS9jHmjAP4cTGLPsEEKUbIKo1wvOp2aW3UK1MNq1kzoEJ0/Kn+3t5XnaOkOHXi+1EKLYFqNWzY4dMuviRrKzZeCpDLi7OjLmgQbsj0lh/o7TZWqrVMTHy1Ks/HMzQmaJQqFQlJZJq4+TlXtzsDgjJ49Jq49baEQKc3IwJoV3/thPaC0PxvVtVGT57lvd66IXgin/njTTCI3LpNXHybglS9har/cl+2I5EJPCyF4huDraW3o4BaICGAqjUsHJnmY13S0awPhx2ymuZucxrIvKvrBJxo27Xi5iby9FI4vB8x0CeblLEAt2neWrEn7BXUrPJidPlN1C9U6kpl6f7EP5WP3+5BOjaUVYDfv2yWDMrQ8j2JA+1LQGHet4M2n1ceKSzbyKZKLMEoVCoSgNhX0GxiZnWLwMWWFaElMzeWFeON4VnPhuUEuc7HVFHlPT05Un29Ti9/BzRCZeMcMojUth17vZ7wWK4Gp2Lp+vPkZTv8r0beZr6eEUigpgKIxOWLA3B2JTSLlaNlHF0pCamcNP20/Tq2E16lStaPb+FWXkVv2B3NwSrRKP7BnCo6F+TF13skSr3PkpiSYLYMTHw08/GVVXweLk/63Uin6x0TSNT/s2Jk8Ixi4vwjbY2Jgos0ShUChKQw33wjMe7528iaX7YtFbqtxOYTIyc/IYOn8vKRk5zBrcskQuga92DcbFQcfkNdaXtVAUbk4FZzJUd7cufYmZm6I5n5rFmAcaYGdnvVm1KoChMDod6ngjBOyILr31YGmZv+MMqZm5vNo12Ox9K4xAGVeJNU1jfL/GdKtflQ+WH+avA3HFOi4+Rdq4mUzwtTyufpfHczID/l6uvNmtLmuPnOefQ2YM9pgws0ShUChKyoieIbg43Lzy7uKgY1iXINxdHXjztwj6TNvG9ijrcLZTlB0hBKMXHyTiXDJfPdaUhjUql+h47wpODOlYm1WHEog4l2yiURqfQ7EppGfloisgIFCjsrPldLFuIT4lg5mbo7i/SXVCA6zbTU4FMBRGp6mfO66OOrOXkWRk5zFn6ym6hPjQyLdkH4oKK8EIq8T2Oju+faI5obU8GP5bRLGuwwRDAMNkSsvlcfW7PJ6TmXi+QyD1qlXkw+WHSSuj/a9CoVDYIn2b+zKhf2N83V3QAF93Fyb0b8zIXvVY8WoHvny0KZeuZPHE97t47qc9nDyfZukhK8rIzM3RLNkXy1vd69KrUelEv1/oVBtPN0c+W3WsxHpnliAnT8/IRQfwqejEuL4Nb7reezeqRviZZN7+vfQC9MZk0j/H0QsY1cv6bFNvxTqVORQ2jaO9HW0CPdlm5qj5r7vPcik9m1fvUdkXNouRVoOdHXT8MLgVj87cwdB54Swc2o7GfoUHteJSMnDU2eHlZiJhzfK4yl0ez8lMOOjsmPhwE/pN38YXq4/zUZ9Glh6SQqFQmJ2+zX3p2/z2Ons7O43+Lfzo3bg6P247zfQNkfT8ejOPtarJ8G51qVLJutLuFUWz7uh5PvvnGPc3qc5rZciSruBkz6v3BPPxX0fYcvIinQqxXrUWZm2O5kh8KjMHtaRnw2o80brWTe9P2xDJpNXHEcDkAU2x11kmtyDiXDKL98Xycpcganq6WmQMJUFlYChMQliwN9EX0s0mTpOVm8fMzVG0CfS0+rQnhXmo7OrA3Oda4+7qyDM/7ubUxfRC901IyaRqZSerrvdTlC+a1XTn6XYBzN1xhlaf/GsTvvAKhUJhTpwddLzcJYhNI+9hcLsA/giPocsXG/lq7QnSs3ItPTxFMTlxPo03FkbQsEYlvnikaZGOI0XxZFt//Dxc+OyfY1atkxKZeIUp605yf+Pq9GxYrcB9XrknmJG9QlgWEcfw3/eTm6cvcD9TIoTgk7+O4F3ByWYMEFQAQ2ESwoK9AcxWRvLn3ljOp2bxWtc6ZulPYRtUq+zMvOdbI4DBc3aRmJpZ4H7xKZlUr2Qi/QuFohDqVasAwIUrWVbvC69QKBSWwtPNkQ8fasi/b3WmS4gPU9adpMsXG/l191mLTPgUxedyejZD5obj7KBj1qBQXByLdhwpCid7HW91r8vhuFRWHow3wiiNj14vGL34AC4OOj58qOEd9x3WJZhR99Vjxf443vgtwuzX9MqD8YSfucw7PepS0dnBrH2XFhXAUJiEkKoV8a7gyPYo0wt55ubpmbEpkqY13QkL9jJ5fwrbIsinAj8+04pLV7J5+sc9pBagORCfkmF1StCK8s8366Nu25aRk8dn/xyzwGgUCoXCugnwdmP6ky358+X2+Hu6MnrxQe6bsoX1x87bhB7C3UZOnp6Xf9lLQmomswa3vKPzTEnp08yXkKoVmbzmODlWGMT6ZdcZ9py+zJgHGuBTsWinlZc6B/Fe73qsPBDP6wv3me2cMnPymLjqGPWrV2JAaE2z9GkMVABDYRLs7DTaBXmzNfKiyb9Ulu+P41xSBq/eE1zmtDRF+aRpTXe+e6olkYlpvDA3/CaPeb1ecD4ly3QCngpFIRRWYhefkkn/6duYuOoYG44nKqHPYqJpmrumaYs0TTumadpRTdPaaZrmqWnaWk3TThqePQz7apqmTdU0LVLTtAOaprW4oZ2nDfuf1DTtacudkUKhKIiWtTxY9FI7vnuqJbl6wXM/hfPE97s4FJti6aEpbuCjFYfZGZ3ExP6NaeHvYdS2dXYaI3uFcPrSVRbuOWfUtstKbHIGE1cdo2Mdbx5ucbvGS2EM7RTE+/fX5++DCby2wDxBjDnbThFzOYMx99cv0CXFWlEBDIXJ6BDsxYW0LE4mXjFZH3q9YPrGKOpVq8i99aqYrB+F7dOprg9fDGjKrlNJvLFw3zXF56Sr2WTn6amuRMEUZqaw1agKTvZomsbsrdE8++Memn60hge/2confx1hzeEEkq9mF3icginAP0KIekBT4CgwClgnhKgDrDP8DHAfUMfwGArMANA0zRMYC7QBWgNj84MeCoXCetA0jV6NqrFmeCc+7tOQ4+fTeOCbrby5cB8xl69aenh3PfN3nuHnnWd5sVNt+rfwM0kfXetVoVWAB1PXneRqtnVooggh+N+SgwhgfL/GJV5YHdKxNmMeaMA/hxN4dcF/ZOeaLoiRmJbJtPWRdG9QlfaG0n9bQQUwFCbDHDoYqw8nEJl4hVfuCVYCjIoi6dPMl7EPNmD14fO8v/QgQohrFqrVjZjaqFAUhxE9Q3BxuLke2MVBxyd9G/Hny+05MLYnC4a04dWudXBz0jFv5xmGzt9Ls4/X0uvrzYxddoiVB+K5kJZloTOwHjRNqwR0AmYDCCGyhRDJQB9grmG3uUBfw+s+wDwh2Qm4a5pWHegJrBVCJAkhLgNrgV5mPBWFQlECHHR2DG4XwMYRXRjWJYhVhxLoOnkTE/4+SkqGyl6zBNujLvLh8sN0rVeFkSa05NQ0jXd71eNCWhY/bjttsn5KwtKIWDYev8DIniGldvN4vkPgtXvVV0wYxPhyzQmy8/S817u+Sdo3JcpGVWEy/DxcqeXlyrbIizwbFmj09oUQfLshktrebvRuXDo/acXdx7NhgVy8ksW0DVFcupJF+JlkAN5feoiM7LwCLd0UClOQf61NWn2cuOQMari7MKJnyLXtLo462gd7X1sZycrNY/+5FHafusSuU0n8sTeGuTvOAFDbx402gV60CfSkTW1Pqle+PSC3dF9soX2VA2oDF4AfNU1rCuwF3gCqCiHiAYQQ8Zqm5afq+QI35h3HGLYVtl2hUFgxlZwdGNmrHk+1rcXkNSeYtSWa38LP8VrXOgxqW4u/D8aX588/q+HMpXSG/fIfgd5uTBnYzORlCaEBnnSrX4XvNkbxRGt/PNwcTdrfnbh4JYuPVhyhZS0PBrULKFNbz4YForPT+GDZYYb9spdpT7bAyb7sAqj5HIlL5bfwczwXFkigt5vR2jUXKoChMClhwd4sj4gjN09vdG/jjccvcDgulUmPNLGpui2F5XmnRwh7T19mzZHEa9supGUxevFBAHVTozAbfZv7Fvt6c7LX0TrQk9aBnryKFEg7FJvC7lNJ7DqVxF/74/h191kAanq6XA9oBHqx90wS7y05RIZB/yXf8SR/DOUAe6AF8JoQYpemaVO4Xi5SEAV9aYg7bL/5YE0biiw9wd/fv+SjVSgUJqGGuwuTH23K8x0CmbDqKOP+OsK0DSdJy8wlJ0/+K5fDzz+rIC0zh+fnhgPww+BQszlajOhZj15TNjNjU5RFswk+XH6Yq1l5fPZwY6PMSwa3C0ADxiw7zLCf/2P6U8YJYggh+GTlEdxdHHjdRt0bVQmJwqSEBXlzJSuX/THGFVbKz77wdXdRXz6KEqNpGmcLqJHNyMlj0urjFhiRQlFyHHR2NPf34MXOQcx5phURY3vw12sdGPNAAxpUr8S6o+cZsegAnSZt4O0/9l8LXuRTzq73GCBGCLHL8PMiZEDjvKE0BMNz4g373yi57gfE3WH7TQghZgkhQoUQoT4+PkY9EYVCUXYa1KjE/OfbMO+51qRmXA9e5FPOPv8sTp5e8MbCCE5dTGf6Ey0IMOOqfki1ivRr7stP208XKo5tatYcTuCvA/G8fm8wwVUqGq3dQe0C+KRvI9YdS+Sl+XtvEqEvLf8eTWR71CXe7FaXyq62YZt6KyqAoTAp7YK80DTj62DsjE5i75nLvNS5Ng5GzuxQ3B3EJ2cWuN1SX34KRVnR2Wk08q3M8x0CmTkolL3vd2fN8E6M69MQfSFmUOXlehdCJADnNE0LMWy6FzgCLAfynUSeBpYZXi8HBhvcSNoCKYZSk9VAD03TPAzinT0M2xQKhQ3Sqa7PNdHuW4lNziArt+wTQgV8vvoY648l8uGDDSwiCPlW97og4Ot/T5i975SMHMYsO0S9ahV5sXOQ0dt/qm0txvdrzIbjF3jp57IFMbJz9Xy68gjBVSrwRBvbzR5UMz+FSfF0c6RhjUpGD2B8u+EkPhWdbMqzWGFdFOYAYUyfcoXCktjZadStWpFB7QLwvTuu99eAXzRNOwA0A8YDE4HumqadBLobfgb4G4gGIoHvgWEAQogkYBywx/D42LBNoVDYKHf6nAsd9y/Df4tg7ZHzRlndvhtZ/F8MMzdF82Qb/zJrP5QWPw9Xnmpbi0V7Y4hMTDNr3xNXHeVCWhaTHmlqskXVJ9r4M7F/YzYev8DQMmRizNtxmtOXrvK/++vb9AKw7Y5cYTOEBXnz39nLRrM42nf2MtsiLzG0Y22cHYwnaKO4uyjMAWJEz5BCjlAobJe74XoXQkQYyjqaCCH6CiEuCyEuCSHuFULUMTwnGfYVQohXhBBBQojGQojwG9qZI4QINjx+tNwZKRQKY1DQ55+zgx1DOwXSq1E11h9L5IV54YR+8i9vLNzH6sMJKphRTP47e5lRiw/StrYnHz7U0KJjeeWeIFwd7c1aGrQ98iK/7j7HC51q09ivskn7Gtjan88fbsKWkxd4YV54ia/Ry+nZTF13kk51fbgnpErRB1gxSsRTYXLCgr2ZuTmaPacv07lu2WuFp22IxN3VwaZTnxSWpygHCIWiPKGud4VCcbdS1Off+Dw926Mu8feBeFYfSWBZRBxujjq61q/K/Y2r0bluFVwc1YLZrcSnZDB03l6qVXJmxpMtLb6i71XBiRc61uarf0/w39nLtPD3MGl/Gdl5jFp8kAAvV4Z3q2vSvvJ5tFVNNA1G/nmAIXPD+X5waLGvza//PUF6dh7v3297tqm3ogIYCpPTKsATR50d2yIvljmAcSQulX+PJvJW97q4OanLV1E2SuIAoVDYOup6VygUdyt3+vxz0NnRua4Pnev68EleI3ZGX+LvgwmsPpzAiv1xuDrquKdeFXo3qs499XxwdVT3nxnZedeyABa80Mai9qU3MqRjIPN2nOazVcdYOLQtmmY6l8Iv1x7nbNJVFg5ta9aM8AGhNbHTNN5ZtJ/n5+5h9tOtigxiRCam8fOuszzR2p+6VY0nMmopLBIq0zTNXdO0RZqmHdM07aimae00TfPUNG2tpmknDc8ehn01TdOmapoWqWnaAU3TWtzQztOG/U9qmvZ04T0qLImLo44WtdzZerLsOhjTNkZS0cmep9sHlH1gCoVCoVAoFAqFAQedHR3r+DChf2N2v3cvvwxpQ7/mvuyKvsQrC/6j5bh/GfbLXlbsjyM9yzil0baGEIIRi/ZzOC6VKQObWdWE2M3Jnte6BrPrVBKbTlwwWT8R55KZvfUUT7bxp21tL5P1UxgPt/Tjy0ebsjP6Es/9tKfIMv1PVx7F1VHH8O7myRQxNZYKIU4B/hFCPKJpmiPgCrwHrBNCTNQ0bRTSv/1d+D97dx4fZX3u//91ZSEBQoCEfZEEpKAoIAaEQq2Uo+CK9Vi7eKq2PVK3tuf7q9bac6xttavd1FYtrRZtqVatW1s32krdQAFBcAFlJywJEEjCkpDl+v1x38EBhmzMZCaT9/PxmEdmPnPf91wfE8mV6/4snA0MDx+nAfcAp5lZHnALUESwR/sSM3va3Xe1fXekKVOO78VPX3ifsr0HyGtllXbN9j08s2IrV398GN07t89tf0REREQk+WWkpzH5+F5MPr4X35t5Em+sK+OZFVt59u1tPLNiG1kZaZwxojfnnNyfaSf0JSccGfzk0s0pN10vsk852RlUVtVy44yRTDuhb6JDO8LnThvCfa+u48fPreL04b1JS4vtKIwDtfXc+Nhy+uZm882zR8b02i3xyVMGYRj/3yPL+MLvF/H7L4yPOjro3+9v58VV2/nfc05o9d9gyabNCxhmlgucDlwB4O4HgANmNhM4IzzsAWA+QQFjJvCguzuwMBy90T88dl7DglxmNg+YATzUVn2R5vvo8b3ghfd5bc0Ozhs9oFXXuPvFNWRlpPGlKYUxjk5EREREJLr0NGPSsHwmDcvnOxeMYvH6D4sZz79TQqeMYBpK39wsHltSTFVNPRBs1XrT4ysA2m0R48mlm7np8RXsDxeNrKyqJd2MfrlZCY4suk4ZaXz9zBH8z5+X8dflW5g5Nrb/3e+Zv4ZVJZXcf0UR3bITe0P1wlMGYgb/78/LuOL3i/j9FeMPmWJfW1fPbX97lyH5Xbjso0MSGGlsJWIKyVBgO/B7M1tqZr8zs65A33APdsKvDcujDgQ2RZxfHLYdrV2S0OiB3emWlcGrq3e26vxNZft4ctlmPjvhOPJzkvMfTBERERFJbelpxmlD8/nuzJNYeNM0Hr1qEpeedhwrisv548KNB4sXDfbX1LXpzhixdvvzqw4WLxrUufPTF95PUERNu2DMAEb268bPXnifA7X1TZ/QTO+XVPKrFz/ggjED+MTI5Bh9MnPsQO74zCks2bCLK37/BnsipjY9tGgTH5Tu4aazTyArI3UWok3EFJIMYBzwFXd/3czuIJgucjTRxv14I+1HXsBsFjAL4LjjtHNFImSkpzFxWD6vrm7dOhi/eWkN6WbMOn1ojCMTEREREWm5tDRjfEEe4wvyuPncExn2rWei/jGyZff+No8tVo4WezL3KS3NuHHGSL4wZxEPL9rIZZMKjvmadfXONx5bTk5WBrecf+KxBxlD548ZQJoZX314Keff+TJVtfVsK6/CDIb17sr0UclRbImVRIzAKAaK3f318PVjBAWNknBqCOHX0ojjB0ecPwjY0kj7Edx9drg3fFHv3se+jae0zuRh+Wws28emsn0tOq+koopHFhfzn6cOon/3znGKTkRERESkddLSjAE9ouep/bpnt3E0sbH/QN1Rd9g4Wl+TxRkjejOhMI87/7k6JguuznltPcs27eY7F4xKytHg547uz2UTj2Pdzn1sLa/CgXqH4l37eWpZ1D+R2602L2C4+zZgk5mNCJumAe8CTwMNO4lcDjwVPn8auCzcjWQiUB5OMXkeOMvMeoY7lpwVtkmSmjK8F0CLR2H89qW11NU7V398WDzCEhERERE5ZjdMH0HnKH/wuztrtu9JQEStt27HXj5596vsr6kj47CFMDtnpnPD9BFHOTM5mAWjMHbsqeb+V9Yd07U2le3jp8+v4hMj+3DBmNat5dcWXni39Ii26tr6dj2FKZqEbKMKfAWYa2bLgbHAD4AfAWea2QfAmeFrgGeAtcBq4LfANQDh4p23AovCx/caFvSU5DSsdw59c7N4pQUFjLK9B5j7+kZmjhnAcfld4hidiIiIiEjrXXjKQH540ckM7NEZAwb26MxVHx9KdW09M3/1Ks+s2JroEJvlube3csFdr1BSUcUDX5zATz815pA+/fCik9vFoqSnDunJmSf25TcvraVs74FWXcPduenxFaSnGbddeBJmsd3VJJba43Sf1kjINqruvoxg+9PDTYtyrAPXHuU69wP3xzY6iRczY/KwXsx/fzv19d6sbY1+/+o6qmrruGaqRl+IiIiISHK78JSBR/xxf9mkAq6Z+ybXzH2TL00p5JtnjyQzPVH3kY+upq6enzy3kt++vI4xg3tw96XjGBhOFWkPBYtobpg+ghm/fIm7X1zN/53X8rUrHl1SzCurd3DbhScl/bSZAT06szlKsSLZ426p5Ps/R1La5ON7Ubb3ACu3VTZ5bEVVDXNeW8+MUf04vk+3NohORERERCS2BvTozCNfnsQVHy3gvlfW8dnZC9lWXpXosA5RWlHFpb99nd++vI7LJg3hkS9PPFi8aM8+0rcbF40bxIMLNkT9474xpRVV3Pa3d5lQmMfnJiT/RhDRpjC1h+k+LaUChrSpycc3fx2MPyzYQGVVLddOPT7eYYmIiIiIxE2njDS+c8Eo7vjMWN7ZUsF5d73Ma2tatztfrC1cu5Nz7nyFFZvLueMzY/nezJNSatvN/3fmvUMFLwAAIABJREFUR8DgF/NatvXrt596h+raen500cnNGjmeaNGmMLWX6T4tkZApJNJx9euezbDeXXl1zQ6ubGRL1H0HarnvlXVMHdGbkwZ2b8MIRURERETiY+bYgZzYP5er/riE//rd61w/fQRXnT4sIX8guzu/eWkttz+/iiH5XfjTlafxkb6pN+p5YI/OXDZxCPe/uo5Zpw9tVh+fXbGV597ZxjfPHsnQ3jltEGVsRJvClGo0AkPa3JTje/H62jIO1NYf9Zg/vb6Rsr0HuO4TGn0hIiIiIqljeN9uPHXdFM4+uT8/eW4Vs/6wmPJ9NW0aQ/n+Gmb9YQk/enYlM0b14+nrpqRk8aLBNVOPp2unjGbtyLF73wFufuodThqYy39PKWyD6KQlVMCQNvfR43uxv6aOpRt3RX2/uraO3768lolD8zh1SF4bRyciIiIiEl85WRn86rOncMv5JzJ/1XbO+9XLvL25vE0++90tFVzwq1d4cWUpN593Ir/63CnkZKX2wPy8rp2YdfpQ5r1bwpINjW9cedvf32P3vgP85D/HkJGEi612dPqOSJubODSfNINX1+yM+v5jS4opqajmK58Y3saRiYiIiIi0DTPjC5ML+fOXJ1JT61x0z2v8edHGuH7mo4s38cm7X6Wqpo6HZ03kS1MKk3pr0Fj64pRCeuVk8eNnVxFsdHmkl97fzmNLirnq48M4cUBuG0cozaEChrS57p0zGT2oR9SFPGvq6rln/hrGDu7BR4flJyA6EREREZG2c+qQPP721SmML+jJjX9ZwTcee4uqmrqYfkZVTR03Pb6cGx5bzqlDevL3r36MooKONdK5a1YGX512PG+sL2P+qu1HvL+3upabHl/BsN5dNY09iamAIQkx+fh8lm3aTWXVofP9nl62heJd+7lu6vEdphosIiIiIh1br5wsHvziaVw39XgeWVzMRXe/xsad+2Jy7U1l+7j43td46I1NXDt1GH/40mn0ysmKybXbm8+MP47j8rrw4+dWUl9/6CiM259fxZby/fz4P0eTnZk6u7CkGhUwJCEmH9+LunrnjXUfzkGrr3funr+aE/rnMu2EPgmMTkRERESkbaWnGddPH8H9VxRRvGsf5971MvPeLTmma/5rZQnn3vkyG3bu43eXFXHD9JGkt4MtQeOlU0YaXz/rI6zcVsnTb2052L5kQxkPLFjPZROHdLiRKe2NChiSEOOO60lWRhqvREwjee6dbazZvpdrpw7T6AsRERER6ZA+MbIvf//qxxiS34UrH1zMj59bSW3d0Xfvi6au3rn9+ZV8cc5iBud14e9f+Rj/cWLfOEXcvpw/egAn9s/lZ/NWcaC2nqqaOr7x2HIGdO/MDTNGJjo8aYIKGJIQ2ZnpTCjM47XVwUKe7s5d/1rN0N5dOfuk/gmOTkREREQkcQbndeGxqz7KZycM5p75a/j8fW+wvbK6Wefu2FPNZfe/zq9fXMOniwbzl6s/ynH5XeIccfuRlmZ8Y8YINpXtZ/z35zHy5udYs30v547ul/K7saQCFTAkYSYf34tVJZWUVlbx4qpS3ttawTVnHN+hh7WJiIiIiEBww++HF43m9otH8+bGXZx758ssWt/4FqBLNpRx3p2vsHj9Ln5y8Wh+fLHWc4hm194DpBmU76892PaHBRt5cunmBEYlzaEChiTM5GG9AHht9U7u+tdqBvXszMyxAxIclYiIiIhI8vhU0WCeuGYynTul85nZC/ndy2uP2AbU3bn/lXV8+jcL6ZSRxuPXfJRLigYnKOLk99MX3uewNTzZX1PH7c+vSkxA0mwaIyMJ80FJJWbwP39eBsDFpw4iM101NRERERGRSCcOyOXp66Zww6Nvcdvf3+PNjbs4fXgv7vrXGrbs3k92Zhr7a+r5jxP68rNLxtC9c2aiQ05qW3bvb1G7JA/9tSgJ8eTSzfzvk28TWTz+2/ItGrYlIiIiIhJF986Z/Obzp3LT2SN5dsU2bnr8bTbv3o8D+2vqyUgzzj2pn4oXzTCgR+cWtUvyUAFDEuL251exv6bukLaqmnoN2xIREREROQoz48sfH0Z+TicOmwFBbb3z03nvJySu9uaG6SPofNjaIJ0z07lh+ogERSTNpSkkkhAatiUiIiIi0jo79xyI2q5cunkuPGUgENxU3bJ7PwN6dOaG6SMOtkvyUgFDEmJAj85sjvIPrIZtiYiIiIg0Trn0sbvwlIEqWLRDmkIiCaFhWyIiIiIiraNcWjoqjcCQhNCwLRERERGR1lEuLR2VChiSMBq2JSIiIiLSOsqlpSPSFBIRERERERERSXoqYIiIiIiIiIhI0lMBQ0RERERERESSngoYIiIiIiIiIpL0ElLAMLP1ZrbCzJaZ2eKwLc/M5pnZB+HXnmG7mdmdZrbazJab2biI61weHv+BmV2eiL6IiIiIiIiISPwlcgTGVHcf6+5F4etvAv909+HAP8PXAGcDw8PHLOAeCAoewC3AacAE4JaGooeIiIiIiIiIpJZkmkIyE3ggfP4AcGFE+4MeWAj0MLP+wHRgnruXufsuYB4wo62DFhEREREREZH4S1QBw4EXzGyJmc0K2/q6+1aA8GufsH0gsCni3OKw7WjtIiIiIiIiIpJiMhL0uZPdfYuZ9QHmmdnKRo61KG3eSPuRFwiKJA2Fkj1mtqpF0TatF7AjxtdMBqnYr1TsE6Rmv1KxT5Ca/UrFPoH61RJDYny9dmPJkiU7zGxDHC6dij9/qdgnSM1+pWKfQP1qT1KxT5Ca/YpXn6LmFgkpYLj7lvBrqZk9QbCGRYmZ9Xf3reEUkdLw8GJgcMTpg4AtYfsZh7XPP8rnzQZmx7IPkcxsccRaHikjFfuVin2C1OxXKvYJUrNfqdgnUL+kedy9dzyum4rfp1TsE6Rmv1KxT6B+tSep2CdIzX61dZ/afAqJmXU1s24Nz4GzgLeBp4GGnUQuB54Knz8NXBbuRjIRKA+nmDwPnGVmPcPFO88K20REREREREQkxSRiBEZf4Akza/j8P7n7c2a2CHjEzL4EbAQ+FR7/DHAOsBrYB3wBwN3LzOxWYFF43PfcvaztuiEiIiIiIiIibaXNCxjuvhYYE6V9JzAtSrsD1x7lWvcD98c6xlaI2/SUBEvFfqVinyA1+5WKfYLU7Fcq9gnUL0msVPw+pWKfIDX7lYp9AvWrPUnFPkFq9qtN+2RBfUBEREREREREJHklahtVEREREREREZFmUwFDRERERERERJKeChjNYGb3m1mpmb0d5b3rzczNrFf42szsTjNbbWbLzWxc20fctBb26dKwL8vN7DUzO2INk2TRkn5FtI83szozu7jtIm2+lvbJzM4ws2Vm9o6Z/btto22+Fv4Mdjezv5rZW2G/vtD2ETdPtH6Z2XfMbHP4fVlmZudEvHdT+O/FKjObnpioG9eSPpnZmWa2xMxWhF8/kbjIG9fS71X4/nFmtsfMrm/7iJvWip+/0Wa2IPz/aoWZZScm8o4lFfMKUG5xWLtyiwRIxdwiFfMKSM3cIhXzCki+3EIFjOaZA8w4vNHMBgNnEuya0uBsYHj4mAXc0wbxtcYcmt+ndcDH3X00cCvJvfjMHJrfL8wsHfgxyb0F7xya2Scz6wHcDVzg7qP4cDefZDSH5n+vrgXedfcxwBnAz8ysUxvE2BpziNIv4BfuPjZ8PANgZicCnwFGhefcHf5MJps5NLNPwA7gfHc/mWBL7D+0UYytMYfm9+vge8CzcY+s9ebQ/J+/DOCPwFXhvxdnADVtFWgHN4fUyytAuUVDu3KLxJlD6uUWc0i9vAJSM7eYQ+rlFZBkuYUKGM3g7i8B0bZo/QXwDSByJdSZwIMeWAj0MLP+bRBmi7SkT+7+mrvvCl8uBAbFP8LWaeH3CuArwF+A0jiH1mot7NPngMfdfWN4bqr0y4FuZmZATnhebdyDbIVG+hXNTOBhd69293UE20VPiFtwrdSSPrn7UnffEr58B8g2s6y4BXcMWvi9wswuBNYS9CsptbBPZwHL3f2t8Nyd7l4Xt+DkoFTMK0C5RQTlFgmSirlFKuYVkJq5RSrmFZB8uYUKGK1kZhcAmxu+OREGApsiXheHbUmvkT5F+hLJXyU8xNH6ZWYDgU8C9yYksGPQyPfqI0BPM5sfDrG7LAHhtVoj/foVcAKwBVgBfM3d69s6vmN0XThU+n4z6xm2tdt/L0LR+hTpP4Gl7l7d1oEdoyP6ZWZdgRuB7yY2tFaL9r36COBm9ryZvWlm30hkgB1dKuYVoNyiPVFu0e5yi1TMKyA1c4tUzCsgQbmFChitYGZdgP8Fvh3t7ShtSb9XbRN9ajhmKkGScWNbxXWsmujXL4Eb29sdxyb6lAGcCpwLTAduNrOPtGF4rdZEv6YDy4ABwFjgV2aW24bhHat7gGEEsW8Ffha2t8t/L0JH6xMAZjaKYAj1l9s+tGNytH59l2Co5J5EBXYMjtanDGAKcGn49ZNmNi0hEXZwqZhXgHKLto3q2Ci3aHe5RSrmFZCauUUq5hWQwNwiI5YX60CGAYXAW8GoMwYBb5rZBIJK5+CIYwcRVHaT3VH75O7bzGw08DvgbHffmcA4W6qx71UR8HDY3gs4x8xq3f3JRAXbTE39/O1w973AXjN7CRgDvJ+oYFugsX59AfiRuzuw2szWASOBNxIVbEu4e0nDczP7LfC38GV7/feisT5hZoOAJ4DL3H1NAsJrtUb6dRpwsZn9BOgB1JtZlbv/KgFhtkgTP3//dvcd4XvPAOOAf7Z5kJKKeQUot1BukXgpmVukYl4BqZlbpGJeAYnNLTQCoxXcfYW793H3AncvIPhGjXP3bcDTwGUWmAiUu/vWRMbbHI31ycyOAx4HPu/u7eGX1UGN9cvdCyPaHwOuaQcJRlM/f08BHzOzjPCuw2nAewkMt9ma6NdGYBqAmfUFRhDMGWwX7ND56p8EGlZxfhr4jJllmVkhwSJ9SZ84wdH7ZMFib38HbnL3VxMR27E4Wr/c/WMRP5u/BH7QXpKMRn7+ngdGm1kXCxbd+jjwblvHJ6mZV4ByC5RbJFyq5hapmFdAauYWqZhXQGJzC43AaAYze4hgBdVeZlYM3OLu9x3l8GeAcwgWzdlHUN1NOi3s07eBfIKVjAFq3b2oTQJtoRb2q11oSZ/c/T0zew5YDtQDv3P3I7YSSwYt/F7dCswxsxUEwyNvbKjsJpto/QLOMLOxBMM41xMOfXT3d8zsEYJ/2GuBa5Nx2HFL+gRcBxxPMMT45rDtLE/CRd9a2K92oYU/f7vM7OfAovC9Z9z974mIu6NJxbwClFu0J8otgHaSW6RiXgGpmVukYl4ByZdbWDBqSkREREREREQkeWkKiYiIiIiIiIgkPRUwRERERERERCTpqYAhIiIiIiIiIklPBQwRERERERERSXoqYIiIiIiIiIhI0lMBQ0TaJTObb2ZJueWeiIiItC/KK0TaBxUwRERERERERCTpqYAhIm3CzL5hZl8Nn//CzP4VPp9mZn80s7PMbIGZvWlmj5pZTvj+qWb2bzNbYmbPm1n/w66bZmYPmNltbd8rERERSQTlFSIdkwoYItJWXgI+Fj4vAnLMLBOYAqwA/g/4D3cfBywG/r/w/buAi939VOB+4PsR18wA5gLvu/v/tU03REREJAkorxDpgDISHYCIdBhLgFPNrBtQDbxJkHB8DHgaOBF41cwAOgELgBHAScC8sD0d2Bpxzd8Aj7h7ZPIhIiIiqU95hUgHpAKGiLQJd68xs/XAF4DXgOXAVGAYsA6Y5+6fjTzHzE4G3nH3SUe57GvAVDP7mbtXxS14ERERSSrKK0Q6Jk0hEZG29BJwffj1ZeAqYBmwEJhsZscDmFkXM/sIsArobWaTwvZMMxsVcb37gGeAR81MBVkREZGORXmFSAejAoaItKWXgf7AAncvAaqAl919O3AF8JCZLSdIPEa6+wHgYuDHZvYWQVLy0cgLuvvPCYaN/sHM9G+aiIhIx6G8QqSDMXdPdAwiIiIiIiIiIo1SVVFEREREREREkp4KGCIiIiIiIiKS9FTAEBEREREREZGkpwKGiIiIiIiIiCQ9FTBEREREREREJOmpgCEiIiIiIiIiSU8FDBERERERERFJeipgiIiIiIiIiEjSUwFDRERERERERJKeChgiIiIiIiIikvRUwBARERERERGRpKcChoi0G2bmZnZ8R/18ERERiR0zO8PMijvq54u0RypgiHQgZvYdM/tjG37eRDObZ2ZlZrbdzB41s/4R72eZ2b1mVhIe81czG9hW8cWSmc0xswNmtifikZ7ouEREROIpAblFQXhDIfL37c0R7//UzD4ws0ozW2lml7VVbLFmZuvNbH9EP19IdEwiiaYChog0m5lltPCUnsBsoAAYAlQCv494/2vAJGA0MADYDdx1zIHSqlhj4SfunhPxqEtADCIiIu3GMfy+7hHx+/bWiPa9wPlAd+By4A4z++ixxgmQoBsT50f086wEfL5IUlEBQyQFmdmNZrY5vPuwysymmdkM4FvAp8Mq/lvhsQPM7OlwBMRqM7sy4jrfMbPHzOyPZlYBXGFmaWb2TTNbY2Y7zewRM8uLFoe7P+vuj7p7hbvvA34FTI44pBB43t1L3L0KeBgY1UT3zjGztWa2w8xuN7O0MNYrzOxVM/uFmZUB3zGzYWb2rzDOHWY218x6RPRvvZldb2bLzazczP5sZtkR799gZlvNbIuZfbEF3wIREZGUkiy5RVPc/RZ3X+nu9e7+OvAywc2Sxvr2rTBPWG9ml0a0zzGze8zsGTPbC0w1s3PNbKmZVZjZJjP7TsTxDaNDLjezjeE1/zfi/c7hNXeZ2bvA+Nb0UaQjUwFDJMWY2QjgOmC8u3cDpgPr3f054AfAn8Mq/pjwlIeAYoIREBcDPzCzaRGXnAk8BvQA5gJfBS4EPh6eswv4dTPDOx14J+L1fcDkMNHpAlwKPNvENT4JFAHjwtgiCwunAWuBPsD3AQN+GMZ5AjAY+M5h17sEmEFQTBkNXAEQJmXXA2cCw4H/aEb/rgmTtSVm9p/NOF5ERCTpJWluscHMis3s92bW6yhxdyYoErwT7f1QP6AXMJBgxMbssL8NPkeQU3QDXiEY4XFZGPu5wNVmduFh15wCjACmAd82sxPC9luAYeFjevh5TZlrwTTcF8xsTNOHi6Q2FTBEUk8dkAWcaGaZ7r7e3ddEO9DMBhP8kr3R3avcfRnwO+DzEYctcPcnwzsZ+4EvA//r7sXuXk1QELi4qSGgZjYa+DZwQ0Tz+8BGYDNQQVBk+F4T/fuxu5e5+0bgl8BnI97b4u53uXutu+9399XuPs/dq919O/BzguQo0p3uvsXdy4C/AmPD9kuA37v72+6+lyMLH4e7k6DQ0Qe4GZhjZpMbP0VERKRdSKbcYgdBUWIIcCpBYWHuUeK+F3gLeL6J/t0c5gr/Bv5OkAM0eMrdXw1jrXL3+e6+Iny9nKBYc3hu8d0wD3kr/PyGwsMlwPfDPGYTQe7QmEv5cBrui8DzkSNJRToiFTBEUoy7rwb+h+CXf6mZPWxmA45y+ACgzN0rI9o2ENyFaLDpsHOGAE+Y2W4z2w28R5DY9D1aTBbs3PEs8DV3fznirXuAbCAf6Ao8TtMjMCLj2RD2IWqsZtYn7P/mcJjqHwnuskTaFvF8H5ATPh8Q5bOOyt3fdPedYfHkGYJk6qIm+iIiIpL0kim3cPc97r44/H1bQjAy5Cwzy408zsxuB04CLnF3b6R7u8IbFZGxNpZbnGZmL4ajIsqBq4hfbvFqWAjZ5+4/JFgr7GONnSOS6lTAEElB7v4nd59CkBA48OOGtw47dAuQZ2bdItqOIxgRcfByh52zCTjb3XtEPLLdfTNRmNkQ4B/Are7+h8PeHgPMCe9EVBMs4DnhaENBQ4MPi3VLI7H+MGwb7e65wH8RTCtpjq1RPqslvAWfJSIiktSSKbc4PLTw68HfuWb2XeBs4Cx3r2ji/J5m1vWwWBvLLf4EPA0MdvfuBKM8lFuItBEVMERSjJmNMLNPmFkWUAXsJ7iLAVACFDQsfBkOX3wN+KGZZYfTPL7E0YdiQvCL+vthYQIz621mM48Sy0DgX8Cv3f3eKIcsAi4zs+5mlglcQzANZEcjn3+DmfUMh6h+DfhzI8d2A/YAu8NYbmjk2MM9QrCw2Inh+hy3NHawmV1sZjnhQmRnERRLnm7B54mIiCSlJMstTgvjSTOzfIJpGPPdvTx8/yaCdSvOdPedzezid82sk5l9DDgPeLSRY7sRjDCpMrMJ4Wc11yPATWEeMwj4ytEONLPjzGxyGFe2md1AMNLj1RZ8nkjKUQFDJPVkAT8imCO6jWBNhm+F7zX8Qt5pZm+Gzz9LML9yC/AEcIu7z2vk+ncQ/GH+gplVAgsJFs+M5r+BocAtFrFfe8T71xMkQh8A24FzCBbpbMxTwBJgGcE81fsaOfa7BIt9lofHPt7EtQ9y92cJ1tj4F7A6/NqYrxHcXdoN3A5c6e7zm/t5IiIiSSyZcouhwHMEW7O/DVRz6HpYPyAY2fBBRO7xrSMvc9A2gkVDtxAUWa5y95WNHH8N8L0wzm8TFCWa67sE00bWAS8Ah49MjdSNYKrtLoL8YgbBKJXmFmVEUpI1PiVMRERERERERCTxNAJDRERERERERJKeChgiIiIiIiIikvRUwBARERERERGRpKcChoiIiIiIiIgkPRUwRERERERERCTpZSQ6gLbWq1cvLygoSHQYIiIiKWPJkiU73L13ouNIBOUVIiIisXe03KLDFTAKCgpYvHhxosMQERFJGWa2IdExJIryChERkdg7Wm6hKSQiIiIiIiIikvRUwBARERERERGRpKcChoiIiIiIiIgkvQ63BoaIiHQsNTU1FBcXU1VVlehQ2r3s7GwGDRpEZmZmokMRERFJGOUWsdPS3EIFDBERSWnFxcV069aNgoICzCzR4bRb7s7OnTspLi6msLAwYXGYWQ/gd8BJgANfBFYBfwYKgPXAJe6+y4Jv+B3AOcA+4Ap3fzO8zuXA/4WXvc3dHwjbTwXmAJ2BZ4Cvubu3Rd9ERKR9UG4RG63JLTSFREREUlpVVRX5+flKMI6RmZGfn58Md5vuAJ5z95HAGOA94JvAP919OPDP8DXA2cDw8DELuAfAzPKAW4DTgAnALWbWMzznnvDYhvNmtEGfRESkHVFuERutyS1UwBARkZSnBCM2Ev3f0cxygdOB+wDc/YC77wZmAg+Ehz0AXBg+nwk86IGFQA8z6w9MB+a5e5m77wLmATPC93LdfUE46uLBiGuJiIgclOjfiamipf8dVcAQERFJIvPnz+e11147pmvk5OTEKJqkMxTYDvzezJaa2e/MrCvQ1923AoRf+4THDwQ2RZxfHLY11l4cpV1ERKTdSqXcQgUMERGRJBKLJCOFZQDjgHvc/RRgLx9OF4km2m0db0X7oRc1m2Vmi81s8fbt25uOWkREJIFSKbdQAUNERJLek0s3M/lH/6Lwm39n8o/+xZNLN7e7z7rwwgs59dRTGTVqFLNnzwbgueeeY9y4cYwZM4Zp06axfv167r33Xn7xi18wduxYXn75Za644goee+yxg9dpuAOyZ88epk2bxrhx4zj55JN56qmnYhJnkisGit399fD1YwQFjZJw+gfh19KI4wdHnD8I2NJE+6Ao7Ydw99nuXuTuRb179z7mTomISNtTbtE+cwvtQiIiIkntyaWbuenxFeyvqQNg8+793PT4CgAuPCW2o/vj+Vn3338/eXl57N+/n/HjxzNz5kyuvPJKXnrpJQoLCykrKyMvL4+rrrqKnJwcrr/+egDuu+++qNfLzs7miSeeIDc3lx07djBx4kQuuOCClJ6T6+7bzGyTmY1w91XANODd8HE58KPwa0PG9TRwnZk9TLBgZ7m7bzWz54EfRCzceRZwk7uXmVmlmU0EXgcuA+5qsw6KiEibUG7RfnMLFTBERCSp3f78qoO/9Bvsr6nj9udXtfgX/3f/+g7vbqk46vtLN+7mQF39EZ/1jceW89AbG6Oec+KAXG45f1STn33nnXfyxBNPALBp0yZmz57N6aeffnDbsLy8vOZ2Awi2HvvWt77FSy+9RFpaGps3b6akpIR+/fq16Drt0FeAuWbWCVgLfIFgROkjZvYlYCPwqfDYZwi2UF1NsI3qFwDCQsWtwKLwuO+5e1n4/Go+3Eb12fAhIiIpRLlFdO0ht1ABQ0REktqW3ftb1H4sDk8wmmpvrvnz5/OPf/yDBQsW0KVLF8444wzGjBnDqlWrmjw3IyOD+vrg892dAwcOADB37ly2b9/OkiVLyMzMpKCgIBm2OI07d18GFEV5a1qUYx249ijXuR+4P0r7YuCkYwxTRESSmHKL9ptbqIAhIiJJbUCPzmyOklAM6NG5xddq6m7G5B/9K+pnDezRmT9/eVKLP69BeXk5PXv2pEuXLqxcuZKFCxdSXV3Nv//9b9atW3fIMM9u3bpRUfHhnZyCggKWLFnCJZdcwlNPPUVNTc3Ba/bp04fMzExefPFFNmzY0Or4REREOhLlFu03t9AiniIiktRumD6Czpnph7R1zkznhukj2s1nzZgxg9raWkaPHs3NN9/MxIkT6d27N7Nnz+aiiy5izJgxfPrTnwbg/PPP54knnji40NaVV17Jv//9byZMmMDrr79O165dAbj00ktZvHgxRUVFzJ07l5EjRx5TjCIiIh3FDdNHkJVx6J/Cyi3aR25hwejKjqOoqMgXL16c6DBERKQFnly6ma8/sow6D/a5/NmnRnPRqYObPA/gvffe44QTTmjRZ93+/Cq27N7PgB6duWH6iJgv6NWeRfvvaWZL3D3atI6Up7xCRKR9uu1v7/K7V9YB0C07g1tnntTs3/fKLWKrJbmFppCIiEjSu2DMAG547C0Gdu/MxrJ9DO3TLW6fdeEpA5VUiIiIpLjC3sGog145WYyNt1riAAAgAElEQVTs1y2uv/uVW8SOppCIiEjS27XvADV1zvlj+gOwcO3OBEckIiIi7VlJeRVpBtNH9eXNjbuoPcZFNaVtqIAhIiJJr7SyGoAT+3fn+D45LFijAoaIiIi0XklFNb1yspg0LJ99B+p4p5GtUCV5qIAhIiJJr6GA0Tc3i0lD81m0vowa3SkRERGRVtpWUUXf3GzGF+QBsGh9WYIjkuZQAUNERJJeSUWwB3mfbtkH75Ss2Fye4KhERESkvSoJCxh9c7M5Lq+LChjthAoYIiKS9LaHIzD65GZxWmFwp0TTSERERKS1ggJGFgDjC/JYvH4XHW2HzvZIBQwREUl6pRVV5GZnkJ2ZTn5OFiP6duvQC3nm5OQAsGXLFi6++OJGj/3lL3/Jvn37WnT9+fPnc95557U6PhERkWRWXVvHrn019MvNBmBCYU927j3Amu17ExxZ4rSX3EIFDBERSXolFdX0CZMMgEnD8lm8fhcHalNnHYy6uroWnzNgwAAee+yxRo9pTZIhIiKSykorGtbWCnKLonAdjMUpNo0kFXMLFTBERCTplVZW0adb1sHXE4fms7+mjuXFu+PzgVu3wsc/Dtu2xeRy69evZ+TIkVx++eWMHj2aiy++mH379lFQUMD3vvc9pkyZwqOPPsqaNWuYMWMGp556Kh/72MdYuXIlAOvWrWPSpEmMHz+em2+++ZDrnnTSSUCQpFx//fWcfPLJjB49mrvuuos777yTLVu2MHXqVKZOnQrACy+8wKRJkxg3bhyf+tSn2LNnDwDPPfccI0eOZMqUKTz++OMx6beIiEgyalhbq2/3oIAxtFdXeuV04o14FjCUW8Sk3ypgiIhI0iutrD54lwTgtMI8zOK4Dsatt8IrrwRfY2TVqlXMmjWL5cuXk5uby9133w1AdnY2r7zyCp/5zGeYNWsWd911F0uWLOGnP/0p11xzDQBf+9rXuPrqq1m0aBH9+vWLev3Zs2ezbt06li5dyvLly7n00kv56le/yoABA3jxxRd58cUX2bFjB7fddhv/+Mc/ePPNNykqKuLnP/85VVVVXHnllfz1r3/l5ZdfZluMkisREZFktC0sYDRMITEziobkxXchT+UWMelzRkyuIiIiEifuTmlF9SEjMHp27cTIfrksWLuTr0wb3rILnnHGkW2XXALXXAP79sG0afDGG1BfD/feC0uXwqxZcMUVsGMHHD4vdP78Zn3s4MGDmTx5MgD/9V//xZ133gnApz/9aQD27NnDa6+9xqc+9amD51RXB0NcX331Vf7yl78A8PnPf54bb7zxiOv/4x//4KqrriIjI/jVnpeXd8QxCxcu5N133z0Yx4EDB5g0aRIrV66ksLCQ4cOHH4xv9uzZzeqXiIhIe1NS8eH27A2KCnry3Dvb2FZeRb/u2Uc7NTrlFm2WW6iAISIiSa18fw0H6urpHVHAAJg0NJ+5r2+guraOrIz02H3ghg3QsAq5e/A6Bsws6uuuXbsCUF9fT48ePVi2bFmzzj+cuzfrmDPPPJOHHnrokPZly5Y1ea6IiEiqKKmoIisjje6dMw+2TQh3OVu0vozzxwyI7Qcqt4gZTSEREZGkVlp56EJbDSYOzaO6tp5lG1u4Dsb8+Uc+wuGUlJfDrl2HJhm7dsGMGcHrXr2OPLeZNm7cyIIFCwB46KGHmDJlyiHv5+bmUlhYyKOPPhp+tPPWW28BMHnyZB5++GEA5s6dG/X6Z511Fvfeey+1tbUAlJUFw2C7detGZWUlABMnTuTVV19l9erVAOzbt4/333+fkSNHsm7dOtasWXMwPhERkVQVbKGafcgf2Cf2z6Vrp/TWTSNRbtFmuYUKGCIiktQaFtrqc9gIjNMK84N1MGK5neqttwbDOyPV1cVkvuoJJ5zAAw88wOjRoykrK+Pqq68+4pi5c+dy3333MWbMGEaNGsVTTz0FwB133MGvf/1rxo8fT3l5edTr//d//zfHHXcco0ePZsyYMfzpT38CYNasWZx99tlMnTqV3r17M2fOHD772c8yevRoJk6cyMqVK8nOzmb27Nmce+65TJkyhSFDhhxzf0VERJLVtvKqg+tfNMhIT2PckJ68sS7G62Aot4hpbmHeUAnqIIqKinzx4sWJDkNERJrpL0uK+fqjb/Hi9WdQ2KvrIe+dd9fL5GRl8PCsSUc9/7333uOEE05o3oedcgpEG2Y5dmwwX7WV1q9fz3nnncfbb7/d6mski2j/Pc1sibsXJSikhFJeISLS/kz96XxGDcjlV58bd0j7Hf/4gF/+832WffusQ6aXHE65RWy1JLeI2wgMMxtsZi+a2Xtm9o6ZfS1s/46ZbTazZeHjnIhzbjKz1Wa2ysymR7TPCNtWm9k3I9oLzex1M/vAzP5sZp3i1R8REUmMhikkh4/AAJhYmM+bG3dTVdPyfc6jWro0GNp5+OMYEgwRERFJHu4edQQGwPjCnrjDmxt2xe4DlVvEVDynkNQCX3f3E4CJwLVmdmL43i/cfWz4eAYgfO8zwChgBnC3maWbWTrwa+Bs4ETgsxHX+XF4reHALuBLceyPiIgkQElFFTlZGXTNOnLd6UnD8jlQW8+bG2OYaMRBQUFBStwhERERae8qq2vZX1N3xNpaAKcM7klGmvFGPLdTjZGOmlvErYDh7lvd/c3weSXwHjCwkVNmAg+7e7W7rwNWAxPCx2p3X+vuB4CHgZkWrLjyCeCx8PwHgAvj0xsREUmU7ZXVUUdfAIwvzCPNYOHa5E80REREJPFKyoO1tfpG2Sq1c6d0ThrYncXtoIDRUbXJIp5mVgCcArweNl1nZsvN7H4z6xm2DQQ2RZxWHLYdrT0f2O3utYe1i4hICimtrKJPbvQCRm52JicP7M7CNY0v5NnR1nuKF/13FBGR9q6kItzd7Cg3RyYU5vHWpvImp6fqd2JstPS/Y9wLGGaWA/wF+B93rwDuAYYBY4GtwM8aDo1yureiPVoMs8xssZkt3r59ewt7ICIiiVRaWU2fbkfeJWkwcWg+SzftYv+B6IlGdnY2O3fuVKJxjNydnTt3kp199O+FiIhIstsW7m7WL8oIDIDxBXkcqKtneXH0nTlAuUWstCa3OHJCcQyZWSZB8WKuuz8O4O4lEe//Fvhb+LIYGBxx+iBgS/g8WvsOoIeZZYSjMCKPP4S7zwZmQ7Ba+DF2S0RE2oi7U1JRddQpJAATh+Xzm5fWsmTDLqYM73XE+4MGDaK4uBgVsI9ddnY2gwYNSnQYIiIirdawPXu0NTAAioYEEwQWrS9jQmFe1GOUW8ROS3OLuBUwwjUq7gPec/efR7T3d/et4ctPAg0rjzwN/MnMfg4MAIYDbxCMtBhuZoXAZoKFPj/n7m5mLwIXE6yLcTnwVLz6IyIiba+yupaqmvqjJhkQ3ClJTzMWrt0ZtYCRmZlJYWFhPMMUERGRdqKkoorunTPJzkyP+n7Prp0Y3ieHRY2sg6HcInHiOQJjMvB5YIWZNWx8+y2CXUTGEkz3WA98GcDd3zGzR4B3CXYwudbd6wDM7DrgeSAduN/d3wmvdyPwsJndBiwlKJiIiEiKKA3nqR5tDQyAnKwMTh7YnQVrG18HQ0RERKSkooq+jeQVECwS/tdlW6ird9LToq1cIIkStwKGu79C9HUqnmnknO8D34/S/ky089x9LcEuJSIikoJKw2GevRuZQgLBdqq/fWkte6tro263KiIiIgKwraK60ZGdABMK8vjT6xtZua2CUQO6t1Fk0hxtsguJiIhIa5RWhiMwGlnEE2DS0Hxq650lG3a1RVgiIiLSTpVWVDVZwCgqCNbBWLxeeUWyUQFDRESSVmllw0JbjY/AOHVITzLSTNNIRERE5Kjq6p3Symr6NVHAGNSzCwO6Z/NGI+tgSGKogCEiIkmrpKKazpnp5DQxLaRrVgZjBvdgwRoVMERERCS6nXuqqav3Jm+MQLAOxqJ1ZdoqNcmogCEiIkmrtLKaPrlZBBtbNW7S0HxWbC5nT3VtG0QmIiIi7U1JuDh4U1NIAIoK8iitrGZj2b54hyUtoAKGiIgkrdKKKvo2sf5Fg0nD8qmr90a3PRMREZGOa1tFw9TUpnOLCQV5ACzSOhhJRQUMERFJWqWV1fRuxjBPgHHH9SQz3VioaSQiIiISRUlYwOjXvekCxvA+OXTvnMmidboxkkxUwBARkaRVWlFFnya2UG3QuVM6pwzuqYU8RUREJKqSiirSDPK7dmry2LQ0Y3xBT43sTDIqYIiISFLaU13L3gN1zRrm2WDisHze3lxORVVNHCMTERGR9qikoore3bLISG/en8FFBXms3bGXHXuq4xyZNJcKGCIikpRKw2GezR2BATBxaB71joZ7ioiIyBG2VVS36MbI+HAdjMUahZE0VMAQEZGkVFoZ3O3o08xFPCFYB6NTRpq2UxUREZEjlFZUtaiAcfLA7mRlpPHGOi3kmSxUwBARkaTUUMBozl7tDbIz0xl3XA8WrlMBQ0RERA61raKqRXlFp4w0xg7uoXUwkogKGCIikpQ+nELS/DslAJOG9uKdLRWU79M6GCIiIhKoqqlj974a+rVgBAbAhMI83tlSzp7q2jhFJi2hAoaIiCSl0spqOmWkkds5o0XnTRyahzu8rlEYIiIiEiqtCKemtrCAMb4gWF9r6UZNI0kGKmCIiEhSKg2HeZpZi84be1wPsjLSWLhWwz1TkZmtN7MVZrbMzBaHbXlmNs/MPgi/9gzbzczuNLPVZrbczMZFXOfy8PgPzOzyiPZTw+uvDs9t2Q+giIgkpZLKYGRnS0dgjBvSkzTTAuHJQgUMERFJSiUV1S2ePgKQlZFOUUFPFqzVCIwUNtXdx7p7Ufj6m8A/3X048M/wNcDZwPDwMQu4B4KCB3ALcBowAbiloegRHjMr4rwZ8e+OiIjE27byoIDRkkU8AXKyMjhxQC5vaB2MpKAChoiIJKXSyqoWbaEaaWJhPu9trWDX3gMxjkqS1EzggfD5A8CFEe0PemAh0MPM+gPTgXnuXubuu4B5wIzwvVx3X+DuDjwYcS0REWnHSipaNwIDgmkkyzbt5kBtfazDkhZSAUNERJJSaWXL9mqPNGlYPqB1MFKUAy+Y2RIzmxW29XX3rQDh1z5h+0BgU8S5xWFbY+3FUdpFRKSdK6moIqsVa2sBTCjIo6qmnre3lMchMmkJFTBERCTp7D9QR2VVLb1bOQJj9KAedM5M1zoYqWmyu48jmB5yrZmd3six0dav8Fa0H3pRs1lmttjMFm/fvr05MYuISIKVVFTTr3t2i9fWAigqyAO0DkYyUAFDRESSTmllwxaqrStgdMpIC9bBWKMRGKnG3beEX0uBJwjWsCgJp38Qfi0NDy8GBkecPgjY0kT7oCjth8cw292L3L2od+/eseiWiIjE2baKqlaP7OzdLYvCXl1ZtF47kSSaChgiIpJ0SiuDrc5am2gATByaz6qSSnbuqY5VWJJgZtbVzLo1PAfOAt4GngYadhK5HHgqfP40cFm4G8lEoDycYvI8cJaZ9QwX7zwLeD58r9LMJoa7j1wWcS0REWnHSo+hgAEwvqAnizeUUV9/xMA8aUMqYIiISNL5cK/21o3AgMh1MDTcM4X0BV4xs7eAN4C/u/tzwI+AM83sA+DM8DXAM8BaYDXwW+AaAHcvA24FFoWP74VtAFcDvwvPWQM82wb9EhGROHJ3tlVU0e8Y8orxBXns3lfD6u17YhiZtFTLVzARERGJs4aVwluzjWqDkwd2p2undBas2ck5J/ePVWiSQO6+FhgTpX0nMC1KuwPXHuVa9wP3R2lfDJx0zMGKiEjSqKiqpaqm/hhHYATrYLyxroyP9O0Wq9CkhTQCQ0REkk5pZTWZ6UbPLpmtvkZmehpFBXksWKt1MERERDqyhhsjx1LAGJLfhd7dsli8XiM7E0kFDBERSTqllVX06da6lcIjTRqWz+rSPWyv1DoYIiIiHVUsChhmxoSCPC3kmWAqYIiISNIprahu9RaqkSYNDdbBWKhRGCIiIh3WtvKggNHvGAoYAEUFPdm8ez+bd++PRVjSCipgiIhI0glGYBx7AWPUgFxysjI0jURERKQDa9jd7FgWB4cP18HQNJLEUQFDRESSTmll9TEN82yQkZ7GhMI8Fq5RAUNERKSj2lZeRY8umWRnph/TdU7oH9wYeUM7nCWMChgiIpJUqmrq2L2vJiYjMCCYRrJ2x96D819FRESkYympqKLvMexs1iA9zRg3pCeLNAIjYVTAEBGRpLI9RsM8G0zUOhgiIiIdWklFFX27H3sBA2BCQU/eL9nDrr0HYnI9aRkVMEREJKl8OE81NonGiQNyyc3OYIGmkYiIiHRIJRXV9I3RyM6GdTCWbNBuJImgAoaIiCSV0nCqR6ymkKSnGRMK8zUCQ0REpAOqq3e276mmX4xGYIwZ3INO6WmaRpIgKmCIiEhSOTgCIwZzVRtMGpbP+p372Fqubc9EREQ6kp17qqmr95iN7MzOTOfkQd15QwWMhFABQ0REkkppZRXpaUZ+104xu+bEocFwT00jERER6Vi2hSM7+8WogAHBNJK3N5ez/0BdzK4pzaMChoiIJJWSimp652SRlmYxu+YJ/XLp0SVT00hEREQ6mJKKYGRn3xgtDg4wobAnNXXOsk27Y3ZNaR4VMEREJKmUVlbHbAeSBmlpxmmFeSxQAUNERKRDiccIjFOPy8MMrYORACpgiIhIUimtqIrp+hcNJg7NZ1PZfop37Yv5tUVERCQ5lVaEU1NzYndzpHuXTEb07aYCRgKogCEiIkklHiMwIFjIE7QOhoiISEeyrbyK3jlZpMdwaioE62C8uWEXtXX1Mb2uNE4FDBERSRoHausp23sgZluoRvpIn27kde3EwrW6WyIiItJRbKuoiun6Fw3GF+ax90Ad722tjPm15ehUwBARkaSxY0/DQluxn0LSsA7GwrU7cfeYX19ERESST2lFdVzyivEFPQG0nWobUwFDRESSRkm40FY8RmBAMI1k8+79bCrbH5fri4iISHIJRmDEvoDRv3tnBvXszGIVMNqUChgiIpI0SiuDERjxWMQTYNLQYB0MbacqIiKS+qpq6ijfX0O/7vHJKyYU5LFofZlGdrYhFTBERCRpNBQw4jFXFeD4Pjn0yumk7VRFREQ6gHiP7CwqyGPHngOs27E3LteXI6mAISIiSWN7RRVpRky3OotkZpw2NJ8Fa7QOhoiISKorqQhujMRtBEZhsA6GtlNtOypgiIhI0iipqCY/DludRZo0NJ9tFVVs2Lkvbp8hIiIiibctHIERjzUwAIb1ziGvaycWrd8Vl+vLkVTAEBGRpFFaWRW3YZ4NJg0L1sHQNBIREZHUVhrnAoaZUTSkp0ZgtKG4FTDMbLCZvWhm75nZO2b2tbA9z8zmmdkH4deeYbuZ2Z1mttrMlpvZuIhrXR4e/4GZXR7RfqqZrQjPudPM4nfLTkRE4q60Mj5bnUUa2qsrvbtlsWCNChgiIiKpbFt5FdmZaeRmZ8TtM8YX5LFh576DxRKJr3iOwKgFvu7uJwATgWvN7ETgm8A/3X048M/wNcDZwPDwMQu4B4KCB3ALcBowAbiloegRHjMr4rwZceyPiIjEWUlFddxHYJgZk4bms2Ct1sEQERFJZSWV1fTLzSae97nHF+YBaBpJG4lbAcPdt7r7m+HzSuA9YCAwE3ggPOwB4MLw+UzgQQ8sBHqYWX9gOjDP3cvcfRcwD5gRvpfr7gs8yEAfjLiWiIi0M7V19ezcG/8CBgTTSLZXVrNWq4aLiIikrJLyKvrEeWTnqAG5dM5M1zSSNtIma2CYWQFwCvA60Nfdt0JQ5AD6hIcNBDZFnFYctjXWXhylXURE2qGdew/gTtwTDQgW8gQ0jURERCSFlVRW0S/OeUVmehqnHNeDN9apgNEW4l7AMLMc4C/A/7h7RWOHRmnzVrRHi2GWmS02s8Xbt29vKmQREUmAeO/VHmlIfhf65WZrIU8REZEU5e5sK6+ib27884rxBXm8t62CiqqauH9WRxfXAoaZZRIUL+a6++Nhc0k4/YPwa2nYXgwMjjh9ELClifZBUdqP4O6z3b3I3Yt69+79/7N35/Ft1lei/z9fyfsmJ15jy8R2EgJJ7BCahCwECm0JS1tSWvhBmbKUQhfaTmfmMgP33pneO/210GGmLdB2WtbAlIHSNg20QFNKKEtYkoCxnRBCNieRHUtOYkvyItmWvveP55HjJHbiRdIjyef9eull+9Ej6ZiI5KvznO85k/ulhBBCxITHnNUejwoMpRTLZxXxjvTBEEIIIVKSr2+Q4GA45s3BAZbWTEdreG+/9MGItVhOIVHAI8AOrfWPht31HBCZJHIj8Oyw4zeY00iWAV5zi8kG4BKl1DSzeeclwAbzPr9Sapn5WjcMey4hhBBJxuM3EhjxuFICxjaSw9397PZ0x+X1hBBCCBE/7WZlZ7kj9gmMc6oKsduU9MGIg9jNk4GVwJeAZqXU++ax/wncAzyjlLoFOABcbd73AnA5sBvoBW4G0FofVUp9D9hinvevWuvIO+PrwFogG3jRvAkhhEhCbl8ApaA4Lz4JjGWRPhh7jzCnLD8urymEEEKI+IhsTY1HBUZuZhoLKgrYsk8qMGItZgkMrfUbjNynAuATI5yvgdtHea5HgUdHOL4VWDCJMIUQQiQIjz/I9JwM0u1x6S9N1fRsKguzeXvvEW5YXh2X1xRCCCFEfAxVYMQhgQFGH4wn3t5PcDBEZpo9Lq85FcVnlSiEEEKcRoc/9qPOhlNKsay2iLf3HiUclj4YQgghRCrxmAmMkjg0BwdYUjOd/sEwzS5vXF5vqpIEhhBCiITg9gXjMoFkuGW10zna089HHn9cX1cIIYQQsdXuCzAtJ52s9PhUQyyeOQ2AzdIHI6YkgSGEECIhePyBuCcwls8y+2DskXGqQgghRCpx+4Jx6X8RUZSXyaySXLbskwRGLEkCQwghhOVCYc3h7v64LjQAnNNyqJpu9MEQQgghROpw+wJxX1csrZnO1v2dsjU1hiSBIYQQwnJHeoKEwprSOI1QHW55bRHv7JM+GEIIIUQqMRIY8V1XLJ45HX9gkJ1u2ZoaK5LAEEIIYTmPLwgQ9y0kYIxT7eodYEe7L+6vLYQQQojoGwyF6fAH4zaBJGJpzXQAtkgfjJiRBIYQQgjLdfjNBEacFxpwrA/G23tlsSGEEEKkgiM9/YR1/NcVzmnZlBdksaWlM66vO5VIAkMIIYTl3OaoMysqMGY4sqkuypFGnkIIIUSKaPca64p4V2AopVhSM50t+46itWxNjQVJYAghhLCcx6zAiNes9hMtqy3inX1HCEkfjISnlLIrpRqUUn80f65RSr2jlNqllPq1UirDPJ5p/rzbvL962HPcZR7fqZRaPez4peax3UqpO+P9uwkhhIiOyIWReDfxBFhSPY12XwBXZ1/cX3sqkASGEEIIy3n8xqz2zLT4zGo/0fJZRfgDg3zQJn0wksDfAjuG/fxD4Mda6zlAJ3CLefwWoFNrPRv4sXkeSql5wLXAfOBS4OdmUsQO/Ay4DJgHXGeeK4QQIskMJTAc8b8wsqTa6IOxWcapxoQkMIQQQljO4wtSmh//qyQRy2ojfTBkG0kiU0o5gSuAh82fFXAx8FvzlMeBNeb3V5o/Y97/CfP8K4GntdZBrfU+YDew1Lzt1lrv1Vr3A0+b5wohhEgybl8Qu01RlBv/BMbcsnzys9LYul8SGLEgCQwhhBCWc/uDloxQjSgryKK2OJe3JIGR6H4C/CMQNn8uArq01oPmzy6g0vy+EjgIYN7vNc8fOn7CY0Y7LoQQIsm0+wKU5mdit6m4v7bNplg8c5pUYMSIJDCEEEJYrsMXsKz/RcSyWUVs3neUwVD49CeLuFNKfRrwaK3fHX54hFP1ae4b7/GRYrlNKbVVKbW1o6PjFFELIYSwgtsXsGSyWcSSmuns6ejhSHfQshhSlSQwhBBCWCoc1nR0By1ptDXc8toiuoODbJc+GIlqJfBZpVQLxvaOizEqMgqVUmnmOU6gzfzeBVQBmPc7gKPDj5/wmNGOn0Rr/aDWerHWenFJScnkfzMhhBBR5fYFKLewsnOp2Qdj634ZpxptksAQQghhqc7efgZC2pIRqsNF+mDINpLEpLW+S2vt1FpXYzTh3Ki1vh54BfiCedqNwLPm98+ZP2Pev1EbM+2eA641p5TUAHOAzcAWYI451STDfI3n4vCrCSGEiDK3z9oLI3VOBxlpNrbINpKokwSGEEIIS0VGqFrZxBOMEa6zS/N4a48kMJLMPwF/r5TajdHj4hHz+CNAkXn874E7AbTW24FngA+APwG3a61DZp+MbwIbMKacPGOeK4QQIokEBkJ4+wYsTWBkptk5x1nIlhZJYERb2ulPEUIIIWInksAos7DUM2J5bRHr3nMxEAqTbpccf6LSWv8V+Kv5/V6MCSInnhMArh7l8d8Hvj/C8ReAF6IYqhBCiDgbGqFq8dbUJTXT+MWre+kJDpKbKR+7o0VWZ0IIISwVWWhYXYEBsHxWET39IZpbvVaHIoQQQogJaPca64pyqxMY1dMJhTXvH+yyNI5UIwkMIYQQluqIbCFJgAqM82qMpluyjUQIIYRITu1DFRjWrivOnTkNpZBxqlEmCQwhhBCW8vgCFGSlkZVutzoUivIymVuWz9vSyFMIIYRISh6fuTXVYW0FRkFWOmeXF0gfjCiTBIYQQghLuX1BS2e1n2j5rCK2tnTSPxi2OhQhhBBCjFO7L0B2up38BOg7sbRmOg0HuhgIyZoiWiSBIYQQwlIef8DyEarDKaXpGwgx93+/yMp7NrK+odXqkIQQQggxRm5fgHJHFkopq0NhcfU0+gZCbG/zWR1KypAEhhBCCEt5/NbOah9ufUMrT20+CIAGWrv6uGtdsyQxhBBCiCTh9iXOhZGl1UZvrS3SByNqJIEhhBDCMlprPJEQGWEAACAASURBVL5gwiw07t2wk8DA8WWefQMh7t2w06KIhBBCCDEebl+Qcov7X0SUFmQxsyiHzdIHI2okgSGEEMIy3r4B+kNhShIkgdHW1Teu40IIIYRIHFpr2n2BhKnsBGOc6taWo2itrQ4lJUgCQwghhGU85gjVRFloVBRmj+u4EEIIIRKHt2+A/sFwwqwrAJZUT6Ozd4A9Hd1Wh5ISJIEhhBDCMm5zVnuibCG5Y/Vcsk8Y55qdbueO1XMtikgIIYQQY9VurivKChJjXQFGBQbA5n2dFkeSGiSBIYQQwjKRWe2JMkZ1zaJK7r6qjopCI568TDt3X1XHmkWVFkcmhBBCiNNxm+uK8gRZVwDUFOdSnJfBFumDERXWD8cVQggxZUW2kCRKBQYYSYw1iyq56uebSLPbJHkhhBBCJAm3N1KBkTgJDKUUFY4snmtsY31DKxWF2dyxeq6sLyZIKjCEEEJYxu0LkJeZRm5m4uXT652FbG/1EgpL0y0hhBAiGQxtTU2gLSTrG1rZ0e4nFNYyoj0KJIEhhBDCMh3+xBmheqK6Sgc9/SH2HZamW0IIIUQyaPcFmJ6bQWaa/fQnx8m9G3YyEDr+YoiMaJ+40yYwlFJXK6Xyze//t1JqnVLq3NiHJoQQItV5/IGEGaF6onqnA4DGg16LI0k9srYQQggRC25f4l0YkRHt0TWWCox/1lr7lVLnA6uBx4H/jG1YQgghpgK3L5hQ+1SHqy3JIyfDTnOrJDBiQNYWQgghos7tC1DuSKx1hYxoj66xJDBC5tcrgP/UWj8LZMQuJCGEEFOB1hqPP5BwV0oi7DbFggoHTa4uq0NJRbK2EEIIEXVuX4Cy/MRKYIw8ot0mI9onaCwJjFal1C+Ba4AXlFKZY3ycEEIIMSp/cJDAQDihGm2dqM7pYHubj8FQ2OpQUo2sLYQQQkTVYCjM4e4gZQlWgREZ0V45rOLiC4urZArJBI1lsXANsAG4VGvdBUwH7ohpVEIIIVKex5zVnqhbSMDogxEcDLPLI408o0zWFkIIIaLqcHc/YQ1lCXhhZM2iSjbdeTF7f3A5c0rzeHvPEcIy5WxCTpvA0Fr3Ah7gfPPQILArlkEJIYRIfR5z1FmiNvEEYxIJQLNL+mBEk6wthBBCRFu7ua4oT+ALIzab4lufmMMuTzcvbmu3OpykNJYpJN8F/gm4yzyUDvwqlkEJIYRIfR6/UYFRmmB7VYerLsolPzONplbpgxFNsrYQQggRbW4zgZHIlZ0AV9TNYFZJLve/vEuqMCZgLFtIPgd8FugB0Fq3AfmxDEoIIUTq8/gjC43ErcCw2RR1TodUYESfrC2EEEJEVbIkMOw2xbcunsNOt58/fyBVGOM1lgRGv9ZaAxpAKZUb25CEEEJMBW5fkOx0O3mZaVaHckp1Tgc7DvnpH5RGnlEka4sEsL6hlZX3bKTmzudZec9G1je0Wh2SEEJMmNsXIM2mKMpN/KFWn1lYQW1xLve9vFuqMMZpLAmMZ8xO4YVKqVuBvwAPxTYsIYQQqc7jD1JakIlSyupQTqm+spD+UJiP3H6rQ0klsraw2PqGVu5a10xrVx8aaO3q4651zZLEEEIkrXZvkNL8TGy2xF5XgFGFcftFs9lxyMdLO9xWh5NUxtLE89+B3wK/A+YC/6K1fiDWgQkhhEhtngSc1T6SeqfRyLPRJX0wokXWFta7d8NO+gZCxx3rGwhx74adFkUkhBCT4/EHKE3w7SPDXXlOBdVFOdz/8i6MokQxFmOq29VavwS8FONYhBBCTCEef5B5FQVWh3FazmnZFOakG30wzrM6mtQhawtrtXX1jeu4EEIkunZvgFkleVaHMWZpdhu3XzSbO37bxMs7PHxyXpnVISWFUSswlFJ+pZRvhJtfKeWLZ5BCCCFSj8cXoDSBR6hGKKWoq3TQJI08J03WFomjojB7XMeFECLRuX2BhG4MPpI1iyo5Y3oO90kVxpiNmsDQWudrrQtGuOVrrRP/kpkQQoiE1R0cpKc/lPCdwiPqnQ4+cvsJnFByL8ZH1haJ447Vczlxl3h2up07Vs+1JB4hhJiMvv4QvsAgZY7kWFdEpNtt3H7RLJpbvfx1Z4fV4SSFsTTxBEApVaqUOiNyG8P5jyqlPEqpbcOO/R+lVKtS6n3zdvmw++5SSu1WSu1USq0edvxS89hupdSdw47XKKXeUUrtUkr9WimV+O1mhRBCAEb1BZAUFRgAdZWFDIY1Ow5JkUA0jXdtIaLnE2eXomEoiTHDkcXdV9WxZlGllWEJIcSEDI1QTYLeWie66lwnzmnZ/ESqMMbktAkMpdRnlVK7gH3Aq0AL8OIYnnstcOkIx3+stT7HvL1gvsY84FpgvvmYnyul7EopO/Az4DJgHnCdeS7AD83nmgN0AreMISYhhBAJwOMPAlCaJAuNSCPP5lbZRhINk1hbiCjZ3mYk425cUQ3Af1yzUJIXQoik1W4mMMqTrAIDIlUYs2k82MWrH0kVxumMpQLje8Ay4COtdQ3wCWDT6R6ktX4NODrGOK4EntZaB7XW+4DdwFLztltrvVdr3Q88DVypjJl7F2N0MAd4HFgzxtcSQghhsUgCI1n2qs5wZFGclyF9MKJnQmsLET3N5nv5b5YZhS/y3hZCJLOhCowkWVec6PPnOqkszJZeGGMwlgTGgNb6CGBTStm01q8A50ziNb+plGoyt5hMM49VAgeHneMyj412vAjo0loPnnBcCCFEEji2hSQ5rpQopah3Fg596BOTFu21hRinRlcXlYXZzC7Np2p6try3hRBJ7VgCIznWFSfKSLPx9Y/PouFAF2/sPmx1OAltLAmMLqVUHvAa8KRS6j5g8DSPGc1/ArMwFimHgP8wj5/YRwo4bmvmWI+PSCl1m1Jqq1Jqa0eHlOUIIYTVPP4gGWk2CrLHNM07IdRVOtjl8dPbP9F/AsUw0VxbiAlobvUObY2qdxbS6OqyOCIhhJg4ty9IToadvMzkWVec6OrFTmY4srjvL1KFcSpjSWBcCfQCfwf8CdgDfGYiL6a1dmutQ1rrMPAQxhYRMCooqoad6gTaTnH8MFColEo74fhor/ug1nqx1npxSUnJREIXQggRRR5z1JmxIzA51DsdhDV80CaNPKMgamsLMX7e3gH2H+mlLpLAqHTg6uzjSHfQ4siEEGJi2n0ByguykmpdcaLMNDtf//gstu7v5M09R6wOJ2GNeQqJuV3jLYxGWxNavSmlZgz78XNAZELJc8C1SqlMpVQNMAfYDGwB5pgTRzIwGn0+p42U1CvAF8zH3wg8O5GYhBBCxJ/bF0ya7SMRdZXGh71GKbWPmmisLcT4RZrR1lcWGl+dxtcmaVIrhEhSHl+A0iTtfzHcNYurKCvI5L6Xd1kdSsIaSwLjNSBLKVUJvAzcjDFh5JSUUk9hLErmKqVcSqlbgH9TSjUrpZqAizCuvKC13g48A3yAcSXmdrNSYxD4JrAB2AE8Y54L8E/A3yuldmP0xHhkjL+zEEIIi3n8gaQZoRpRWpBFeUEWzVJqHw0TWluI6IhsF4kk5eqcDpSCpoOSwBBCJKdIBUayy0q38/ULZ7F531HekiqMEY1lk5DSWveaCYgHtNb/ppRqON2DtNbXjXB41CSD1vr7wPdHOP4C8MIIx/dybAuKEEKIJOLxBzl/drHVYYxbndMhV6mjY0JrCxEdzS4v1UU5OHLSAcjLTGNWSR7NrZKcE0IkH601bl8waRt4nujapWfw87/u4b6XP2L5rOVWh5NwxlKBoZRSy4HrgefNY8nbHUUIIYSl+vpD+AODlCbhQqO+0sHejh78gQGrQ0l2srawUHOrlzpz20hEfaWDRpdXGscJIZJOV+8A/YPhlElgZKXb+eqFs3h771He2StVGCcaSwLjb4G7gN9rrbcrpWox+k8IIYQQ4+bxR0aoJtcWEmCo6eG2VmnXMEmytrDI4e4grV191JvbRyLqnQ46/EHazVGEQgiRLNqTfITqSK4/7wyK8zK5f6P0wjjRaRMYWuvXtNaf1Vr/0Px5r9b627EPTQghRCry+I1JB8lYgRHpGSCl9pMjawvrNJtNaCMjVCPqq4yKjEbpgyGESDJuM4FR7ki+CyOjyUq387ULa9m0+whbW45aHU5CGfMUEiGEECIaPD4jgVGWhN3Ci/IyqSzMpkkmkVhCKZWllNqslGpUSm1XSv1f83iNUuodpdQupdSvzcllmNPNfq2U2m3eXz3sue4yj+9USq0edvxS89hupdSd8f4dY63J5UUpmH9CBca8GQWk2ZQk54QQSSeSwEi26Wan88XzzqAoN0MmkpxAEhhCCCHiKtkXGgurHENjKEXcBYGLtdYLgXOAS5VSy4AfAj/WWs8BOoFbzPNvATq11rOBH5vnoZSahzGafT5wKfBzpZRdKWUHfgZcBswDrjPPTRnNrV3MKskjL/P4liNZ6XbOLMuX5JwQIum4fZHKzuS7MHIqORlp3HZBLa/vOsx7BzqtDidhnDaBoZRaOZZjQgghxFh4/EHS7Ypp5gSEZFNXWcj+I714e6WR50RNdG2hDd3mj+nmTQMXA781jz8OrDG/v9L8GfP+TyillHn8aa11UGu9D9iNMdlsKbDb3NLSDzxtnpsStNY0urwn9b+IWFjloEkaeQohkky7L8D03Awy0+xWhxJ1X1o+k+m5Gdz3F6nCiBhLBcYDYzwmhBBCnJbHH6A0Pwvjc2TyifQOaJJS+8mY8NrCrJR4H/AALwF7gC6t9aB5iguoNL+vBA4CmPd7gaLhx094zGjHU4LbF6TDHzyp/0VEvbMQb98A+4/0xjkyIYSYOI8vkFINPIfLyUjj1lW1vPpRB+8flHUHnGJkmTnebAVQopT6+2F3FQCpl94SQggRFx5fkJIknEASsaDCTGC4vKyaU2JxNMklGmsLrXUIOEcpVQj8Hjh7pNMiLznKfaMdH+nCzknlCEqp24DbAM4444wxRJ0YmlzG4vfEEaoRkcRGo6uL6uLcuMUlhBCT0e4LJGVfrbH60vKZ/PK1Pdz/8i4evWmJ1eFY7lQVGBlAHkaSI3/YzQd8IfahCSGESEVGBUbyLjQcOelUF+UMTXMQ4xK1tYXWugv4K7AMKFRKRS7KOIE283sXUAVg3u8Ajg4/fsJjRjt+4ms/qLVerLVeXFKSPEms5lYvdpti3oyCEe8/syyfzDSbvLeFEEnF7QtSnqIVGAB5mUYVxsYPPUOJ6Kls1AoMrfWrwKtKqbVa6/1xjEkIIUQK8/iDnFdTZHUYk1LnLOS9/dJQa7wmu7ZQSpUAA1rrLqVUNvBJjMacr2AkQJ4GbgSeNR/ynPnzW+b9G7XWWin1HPDfSqkfARXAHGAzRmXGHKVUDdCK0ejzixP+hRNMo8vLnNI8sjNGLnZJt9uYV1EgjTyFEEljIBTmcHcwZbeQRNywfCYPvraX+1/excM3Tu0qjFNtIfmJ1vo7wE+VUieVT2qtPxvTyIQQQqScwECIrt6BpK7AAKivdPCHxjYOdwcpzkvu3yWeorC2mAE8bk4LsQHPaK3/qJT6AHhaKfX/Aw3AI+b5jwD/pZTajVF5ca35OtuVUs8AHwCDwO3m1hSUUt8ENmBsaXlUa719cr91YtBa0+zq4pJ55ac8b6GzkGe2HiQU1thtydmnRggxdRzuDqI1KZ/AyM9K55bza/jRSx+xrdXLglGaMU8FoyYwgP8yv/57PAIRQgiR+jr8qTHqrM7sFdDc6uWiuaUWR5NUJrW20Fo3AYtGOL4XY4LIiccDwNWjPNf3ge+PcPwF4IWJxJfIXJ19dPYODL13R1PvdLD2zRZ2e7qZW54fp+iEEGJi2r3GaPZyR3KvK8bippXVPPy6UYXx4A2LrQ7HMqfaQvKu+fXV+IUjhBAilXmGEhjJfaVkfkUBSkGzSxIY4yFrC+s0txrbQkabQBJRbzb4bHJ1SQJDCJHw3D5zXZGf3OuKsSjISufL59fwk7/s4oM2H/MqRu5nlOpOO0ZVKbVSKfWSUuojpdRepdQ+pdTeeAQnhBAitXh8xpWSZN9Ckp+VTm1xrvQKmCBZW8Rfo6uLdLs6bVKitjiXvMw0eW8LIZKC2xepwEj9BAbAzStqyM9M44GNu6wOxTKn2kIS8Qjwd8C7QCi24QghhEhlQxUYKXClZKGzkE17DlsdRrKStUWcNbu8nD2jgMy0U0+rtdkUCyoLpNO9ECIpuH0B0u2K6TkZVocSF46cdG5eWc39G3fzYbuPs8qnXhXGaSswAK/W+kWttUdrfSRyi3lkQgghUo7HH8BuUxTlJv9Co87pwO0LDl39EeMia4s4Coc1za1e6sbY9G2hs5Adh/z0D4ZjHJkQQkxOuy9AaX4WtinUdPjL59eQl5nGAy/vtjoUS4wlgfGKUupepdRypdS5kVvMIxPHWd/Qysp7NlJz5/OsvGcj6xtarQ5JCCHGze0LUpKXmRILjUgvASm1nxBZW8TR/qO9+AODp+1/EVHvLKQ/FObDdl+MIxNCiMnx+IJJ3xh8vApzMrhpRTUvbDvER26/1eHE3Vi2kJxnfh3e6lQDF0c/HDGS9Q2t3LWumb4Bo8q2tauPu9Y1A7BmUaWVoQkhxLh4/Kmz0Jg3w4FNQbOri0/NK7M6nGQja4s4imwHqassHNP5w5NzkaaeQgiRiNp9AeaU5lkdRtzdcn4Nj23axwMbd/PAdScN50ppp01gaK0vikcgYnT3btg5lLyI6BsIce+GnZLAEEIkFY8vgHNajtVhREV2hp0zy/JpapUKjPGStUV8Nbm8ZKbZOLNsbIt857RspuWkm4mPmbENTgghJsHtC3D+7GKrw4i7abkZ3LCiml+8uoe//cRsZpdOnalRp01gKKX+ZaTjWut/jX44YiRtXX3jOi6EEInK4w9y7sxpVocRNXWVDjZ+6EFrjVLJvy0mXmRtEV/NLi/zKwpIs49l5zAopah3Fsr2KCFEQuvtH8QfGKQsyUezT9Stq2p5/M0WHti4m/uunTpVGGP5l6xn2C0EXAZUxzAmcYKKwuxxHRdCiETUPxjmaE9/0o9QHa7e6eBITz9tXmnkOU6ytoiTUFizrW38W0EWOh185PbT2z8Yo8iEEGJy3D5jsllZimxNHa/puRl8adlM/tDYxp6ObqvDiZvTJjC01v8x7PZ94OOA7FuIo69/fNZJx7LSbdyxeq4F0QghxMQc7k6dEaoRdeaHwmYZOTkusraInz0d3fT2h8Y8gSSi3llIWMMHbdLIUwiRmNrNiwflU7QCA+DWC2rJTLPzs41TZyLJ2GoJj5cD1EY7EDE6X2AA4LirlleeUyH9L4QQSSUybjSVrpScVZ5Pmk1Jqf3kydoiRiLvzYVV401gGOc3yntbCJGgPH5jXVE6hRMYxXmZ/M2yM1j/fiv7DvdYHU5cnDaBoZRqVko1mbftwE7gvtiHJgAGQ2H+6639rJxdxOb/9Un23X058ysK2NLSSTisrQ5PCCHGzONPvQqMrHQ7c8vzaZZGnuMia4v4aXZ1kZthp6Z4fF36SwuyKC/IGppgIoQQiWaoAsOROuuKibjtglmk22387JWpUYUxlgqMTwOfMW+XABVa65/GNCox5M8fuDnkDXDTihrAaKz11Qtnsbejh7/scFscnRBCjN1QAiOFKjCAoWaHWktSeRxkbREnjS4v8ysd2G3jbzJb73RIdZEQImG5fUFyM+zkZZ52LkVKK8nP5PrzZvL7hlb2H0n9Koyx9MDYP+zWqrWWbk5xtHZTC1XTs7n4rNKhY5cvKMc5LZtfvrbXwsiEEGJ8PL4ANgVFuRlWhxJV9U4H3r4BDh6VyVBjJWuL+BgIhfngkI+FzvFtH4lYWFXIvsM9ePsGohyZEEJMntsXoGyKV19EfO3CWtJsakpUYUykB4aIk22tXja3HOXG5dXHXTlJs9u4dVUt7+7vZGvLUQsjFEKIsfP4ghTlZY55lGOyiDRHbJRSe5FgPnL76R8MDzWbHa9IH4xtskVKCJGA3L4AZSm0LXUySguyuG7pGax7r5WDR3utDiemUmsVmWIef7OF7HQ7Vy+uOum+qxc7mZaTzi9elSoMIURy8PgDKTVCNeLMsnwy0mzSB0MknGZz+0f9OCeQREhyTgiRyNp9gSnf/2K4r104C5tS/PyvqV2FIQmMBHWkO8izjW18/mOVOLLTT7o/JyONG5ZX85cdbnZ7ps7cXyFE8vL4g5SlYKfwjDQbZ88okGaHIuE0urwUZKUxsyhnQo8vzMlgZlEOTQclOSeESCxaazy+YMr11ZqMckcWS2um8dTmg9Tc+Twr79nI+oZWq8OKOklgJKintxykfzDMjcurRz3nhuUzyUyz8ZD0whBCJAG3L5iSFRhgXOHe1uqT6VAioTS3dlHvLESp8TfwjDCa1EpyTgiRWDp7B+gPhSlPwQsjE7W+oZWtLZ0AaKC1q4+71jWnXBJDEhgJaMAcnbpqTjFzyvJHPa8oL5NrFlfx+4ZW3L5AHCMUQojxGQyFOdKTugmMOqeD7uAg+6ZA92+RHAIDIXa2+6mbYAPPiIVOB23eAB3mFCEhhEgEkc8+qVjZOVH3bthJYDB83LG+gRD3bthpUUSxIQmMBLRhezvtvgA3rag+7blfWVXDYDjMY5taYh6XEEJM1JGefrQ2mkylokizw2YZOSkSxM52PwMhPeH+FxGRPhjNrVKFIYRIHO2SwDhJW9fI09BGO56sJIGRgNZuamFmUQ4XzS097bkzi3K5rG4GT769H39AxpwJIRJT5EpJqlZgzC7JIyvdRpMkMESCiGz7mGwFxoJKBzYFjdIHQwiRQDxDCYzUXFdMREVh9ojHU63RqSQwEkyzy8vW/Z3csLwam21se1a/ekEt/uAgT20+EOPohBBiYjw+o/w8VSsw0uw25lc45Cq1SBhNLi9FuRlUjrKgHavczDRml+ZJHwwhREJp95rrChmjOuSO1XPJTrefdLwgK42BUHiERyQnSWAkmLVvtpCTYefqxc4xP6beWciKWUU8+kYL/YOp8+YUQqQOj7l/PpWvlNQ7jUaeIWnkKRJAc6uXOqdjUg08I4xGnl60lve2ECIxtPsCFOVmkJEmH2cj1iyq5O6r6qgszEYBlYXZXLukip3ubv55/baU+Ts8zeoAxDGHu4P8obGNa5dWUZB18ujUU/nqhbO48dHNPNfYxhc+NvbkhxBCxIPbF0ApKM5L7QTGY5ta2NPRzZmnaMAsRKz19g/ykdvPJfPKovJ8C50OfvuuizZvYNIVHUIIEQ0eX0D6X4xgzaJK1iyqPO5YSX4mD2zcTdX0HG6/aLZFkUWPpKwSyFPvHKA/FOaGU4xOHc0Fc4o5qzyfB1/bI2P8hEhA6xtaWXnPxpSey30qHn+Q6TkZpNtT95+duspCABoPSqm9sNYHbT7CGuqchVF5vsjzNMl7WwiRINp9gZSu6oymv//Umaw5p4J7N+zk2feTf/2ZuivJJDMQCvNfb+/ngjNLmF2aN+7HK6X46oW1fOTu5q8feWIQoRBiotY3tHLXumZau/pSei73qXT4Aynb/yKitjiX3Aw7za3S7FBYK9JMtn6SDTwjzp6RT7pd0ShNaoUQCcLtC6Zcc8pYUUrxwy/Uc17NdO74TRPv7D1idUiTIgmMBPHitnY8/iA3j2F06mg+XV9BhSOLX7y6N3qBCSEm7d4NO+kbCB13LBXncp+K2xdM2QkkETabYkGlQyaRCMs1t3opK8iMWnl1Zpqds8oLpJGnECIhDITCHOkJSgPPcchMs/PglxZTNT2b2/7rXXZ7uq0OacIkgZEg1m7aR3VRDheeWTLh50i327hlVS2b9x3lvQOdUYxOCDEZU2Uu96l4/IGUT2CAccX7g0O+lOr2LZJPo6traEtTtNQ7HTS3emWbqhDCch3+IFqn3njQWHPkpLP25qWk2xU3r93M4e6g1SFNiCQwEkDjwS7eO9DFjSvGPjp1NNcuqcKRnc6DUoUhRMIYbS73aMdTTSisOdzdPyWabdU5C+kfDPOR2291KGKK8gcG2NvRE7XtIxH1Tgf+wCAtR3qi+rxCCDFe7b4AkNqTzWKlanoOD9+4hA5/kK88vpW+/tDpH5RgJIGRAB5/s4XcDHtUpofkZqbxpWUz2fBBO/sOyyJDiERwx+q5nJiazE63c8fquZbEE29HeoKEwprSKbDQqK80PjQ2yzYSYZFtrT4gev0vIuojjTzlvS2EsJhnKIGR+hdGYuGcqkLuv3YRja4uvvPrhqQb/y4JDIt5/AH+0NTG1YuryB/n6NTR3LiimnS7jYdelyoMIRLBmWX5aMCRbfw/brcpfvC5BSeNuUpVHp9RojgVtpDMLMohPyuNJmnkKSzS3Gr0qairjG4CY05pHlnpNhqlD4YQwmLtXiOBUS4JjAm7ZH45//LpeWzY7uYHL+ywOpxxkQSGxZ565yADIc0Ny2dG7TlL8jP5/LlOfvuuiw5/cu5tEiKV/L7BRbpd8cr/+Dj3XFVHKKyZU5ZvdVhxE/l7qGQKNNtSShm9AuQqtbBIo8tLZWE2RXnRTRim2W0sqJAmtUII67n9QdLtimk5GVaHktRuXlnDzSureeSNfazdtM/qcMZMEhgW6h8M86t39vPxuSXUlox/dOqp3LqqhoFQmMffbInq8wohxicU1jz7fhsfn1vK9NwMLplfjt2meHHbIatDixv3FNurWu8s5MN2H8HB5NtXKpJfs8sb9e0jEXVOB9vbvAxKk1ohhIXc3gCl+VmT7h0o4H9fMY9L5pXxf//4AX/e3m51OGMSswSGUupRpZRHKbVt2LHpSqmXlFK7zK/TzONKKXW/Umq3UqpJKXXusMfcaJ6/Syl147DjH1NKNZuPuV8plXTv4Be3HaLDH+SmSYxOHU1tSR6r55XzxFst9AQHo/78Qoix2bT7MB5/kKvM7SLTczNYXlvEC83taJ1cew4nyjNUgTFFEhiVDgZCmg8PSSNP15e0hAAAIABJREFUEV9dvf0cONo71K8i2hY6CwkMhNmVxOP3hBDJz+0PTJmLIrFmtynuu3YR9ZUOvv10A40HE3+bYCwrMNYCl55w7E7gZa31HOBl82eAy4A55u024D/BSHgA3wXOA5YC340kPcxzbhv2uBNfK+E9tqmF2uJcLpgz8dGpp/LVC2vxBQZ5esvBmDy/EOL01r3noiArjYvPLh06dnndDPYd7mHHFPmA6/EHKMxJJzPNbnUocVFnXv2WPhgi3prN91ysKjAiz9skfTCEEBZq9wZkhGoUZWfYefjGJRTnZXLL41s5eLTX6pBOKWYJDK31a8DREw5fCTxufv84sGbY8Se04W2gUCk1A1gNvKS1Pqq17gReAi417yvQWr+ljUuYTwx7rqTQcKCT9w9GZ3TqaBadMY2lNdN55PW9DEi5pxBx1x0cZMN2N59eWHHch/dL5pdhU0yZbSRuX5CyKdD/IqKyMJvpuRk0y4c8EWeR/hQLotzAM6K6KJf8rDQapQ+GEMJCHl+Q0im0roiHkvxM1t68hP7BEDev3YK3d8DqkEYV7x4YZVrrQwDm18glyUpgeJmAyzx2quOuEY4njcffbCEvM43PR2F06ql87cJa2rwBnm+aGh+UhEgkf9rWTt9AiM+fe/xfT8V5mSyrLeL55kNTYhuJxx+cEiNUI5RS1FVKs0MRf02uLmqKc4cmHkWbzSZNaoUQ1uoJDuIPDkoFRgzMLs3nwRsWs/9ID1/91Vb6BxPzAniiNPEcqQRBT+D4yE+u1G1Kqa1Kqa0dHR0TDDF6PL4Azzcf4urFTvIy02L6Wh8/s5Qzy/L4xat7psQHJSESye8bXMwsyuHcM6addN/ldTPY29HDR+7U30ve4QtMmf4XEfVOB7s83fT1SyNPET/NLm/Ux6eeqK5SmtQKIawz1RqDx9uy2iLu/cJC3t57lDt/15SQnx/jncBwm9s/ML96zOMuoGrYeU6g7TTHnSMcH5HW+kGt9WKt9eKSktj0mxiPJ985wGBYc+Py6pi/ls2muHVVLR+2+3lt1+GYv54QwnDI28ebe46w5pxKRuoxvHp+OTYFzzendnVUOKzp6A5SNsVmtddVOgiFNR8c8lkdipgiOvxB2ryBmPW/iFjoNJrUTpUePkKIxNI+lMCYWuuKeFqzqJL/ccmZrGto5cd/2WV1OCeJdwLjOSAySeRG4Nlhx28wp5EsA7zmFpMNwCVKqWlm885LgA3mfX6l1DJz+sgNw54roQUHQzz5zgEumltKdXFuXF7zynMqKSvI5Jev7onL6wkhYH1DG1rDVeeOvLutJD+TpTXTeSHFExidvf0MhDSlU64Cw5gCIX0wRLw0txrvtVhXYNRXGe9taeQphLCCx2dMNpMERmzdftFsrlns5P6Xd/HM1sQaCBHLMapPAW8Bc5VSLqXULcA9wKeUUruAT5k/A7wA7AV2Aw8B3wDQWh8FvgdsMW//ah4D+DrwsPmYPcCLsfpdoumF5kMc7o7N6NTRZKTZuOX8Gt7cc0QWHELEgdaade+5+NjMacwsGj1ReXndDHZ7utnlTt0rmZERqlOt2VZZQSYl+ZkyiSTKlFJVSqlXlFI7lFLblVJ/ax6f8mPam1xelIpdA8+ICkcWxXkZNB6U97YQIv6kAiM+lFJ8/3N1rJpTzP9c18wbCVTJH8spJNdprWdordO11k6t9SNa6yNa609oreeYX4+a52qt9e1a61la6zqt9dZhz/Oo1nq2eXts2PGtWusF5mO+qRNxg84JtNY8tqmFWSW5rJpTHNfXvm7pGeRnpvHL1/bG9XWFmIq2t/nY5eketfoi4tIF5agU30YSSWBMtb2qSinqK6XZYQwMAv+gtT4bWAbcrpSah4xpp9nlZXZJHrkx7q0VaVIbqfgQQoh4cvsC5GWmxbyPoIB0u42fXX8us0vz+Pqv3mVne2JccEuUJp5TQsPBLppcXm5aUT3invhYys9K5/plM3mx+RAHjiT2bF8hkt2691rJsNv4dF3FKc8rzc9iSXVqbyOJNNuaahUYYGwj2d3RTU9w0OpQUobW+pDW+j3zez+wA2MK2ZQe0661ptHlpS7G/S8i6p2F7PbIe1sIEX9uX2DKXRSxUkFWOo/etIScTDs3P7Z5aF1nJUlgxNHaTS3kZ6Zx1bmxHZ06mptXVpNms/HwG1KFIUSsDIbCPNfYysVnleLIOf0ow8sXlPORu5vdnsTIakdbR2QLyRRcbNQ7HWgN22QbSUwopaqBRcA7TPEx7e2+AIe7g9THePtIxMIqB2F5bwthufUNray8ZyM1dz7Pyns2sr6h1eqQYs7tm3qNwa1WUZjNozctwds3wJfXbrE8eS0JjDhx+wK80HyIa5ZUxby8czRlBVmsWVTBM1sPcqQ7aEkMQqS613cd5nB3/2m3j0RcVjcDpeCF5vYYR2YNjy9AQVYaWel2q0OJu0gvgmb5kBd1Sqk84HfAd7TWpxr1EpMx7Yk2nr3J3KoUabAZa5EmtU2yRUoIy6xvaOWudc20dvWhgdauPu5a15zySYx2b4BySWDE3fwKBz+9/lw+bPfzracaGAyFLYtFEhhx8uTb+wlpzQ3LZ1oax20X1BIYCPPEW/stjUOIVLWuoZVpOel8fG7p6U/GSCwunjktZbeRuH1BSqfoQqMkP5MKR5Z8yIsypVQ6RvLiSa31OvNwXMe0J9p49maXF7tNMW9GQVxerzgvk8rCbGlSK4SF7t2wk76B0HHH+gZC3Lthp0URxZ7WGo8/MGXXFVa7aG4p/3rlfDZ+6OH//GE7VrWglARGHERGp37irNJTTiSIh9ml+Xzy7DKeeKuF3n7ZuypENPkCA/x5ezufWVhBRtrY/3q9bMEMPmz3s7ejO4bRWcPjD0y5EarD1TkdUoERReZEkEeAHVrrHw27a0qPaW90dXFmWX5cK53qKh0y2UwIC7V19Y3reCo42mOMZi+fgttSE8X1583kaxfO4ldvH+Ch161pSyAJjDj4Y+MhjvT0c9OKGqtDAeBrF9bS2TvAb7a6Tn+yEGLM/tTcTnAwzOcWjW/L/GV15QApWYXh8U/tvar1zkL2He7B2zdgdSipYiXwJeBipdT75u1ypvCYdq01za3euPW/iKivcrD/SC9dvf1xfV0hhGG0f1srCrPjHEn8uH2RyWZTd12RCP5x9Vw+XT+DH7zwIYv+9c9x78EiCYwY01qz9s0WZpfmsXJ2kdXhALC4ejofmzmNh17fa+n+JSFSzboGFzXFuZwzzn3oMxzZnHtGYcr1wdBa4/EFp3YFhvmhcrtUYUSF1voNrbXSWtdrrc8xby9M5THtrs4+unoHqK+KbwJjofTBEMJS9c6Tt4xlp9u5Y/VcC6KJj8gEjDKHJDCsZLMpLjyzBJuCzt6BuPdgkQRGjL13oJPmVmtGp57KVy+oxdXZxwvbUusDkxBWcXX28vbeo1y1qHJC/69fXjeDDw75aDncE4PorOHtG6A/FKZEEhjSK0DEzFADz8r4NPCMiDSplW0kQsRfb/8gm1s6WVBRQKVZcWFT8L0r57NmnFWgyWQogSEVGJb7yV92ET4hvR+vHiySwIixxza1kJ+VNuaJBPHyybPLqC3J5cHX9ljWgEWIVPLs+0afv4kuHC6rmwHA8ym0jcTjl1LPabkZVE3PplmuUosYaXJ1kWG3cWZ5Xlxf15GdTk1xrlRgCGGB373roqt3gO9+dj6b7ryYX91yHmE9wsikFNNuJjCmcmVnorCyB4skMGLokLePF7e1c+2SKnIyrBmdOhqbTXHbqlq2tfp4c88Rq8MRIqlprVn3noul1dOpmp4zoeeoLMzmnKpCXtyWOgkMtyw0AOPKeFOrXKUWsdHk8nLWjHwy0+I/qrje6ZAEhhBxFgprHnljHwurClk8cxoAK2cXcVZ5Po+8sS+lL0y6fUGK8zJIt8tHWKuN1mslHj1Y5E8/hp58+wBhrblhebXVoYxozaJKSvIz+cWre6wORYik1uTysqejZ9KVVlfUzWBbq48DR3qjFJm1PGazrak+7qze6eDg0T46e6TZoYiucFizrdVLvTO+/S8i6p2FtPsCeMxkpRAi9l76wE3LkV5uW1U7tGVVKcWXV9bwYbuft1L4wqTbF5jSVZ2J5I7Vc8k+YfJVvHqwSAIjRgIDIf578wE+eXbZhK/IxlpWup2bV1bz+q7DbG+TKyhCTNTvG1rJSLMNbQOZqEsXmNNIUqQKI7KFZKpXYNQ5pQ+GiI19R3rwBwfj3v8iYqH53m6UKgwh4ubh1/finJbN6vllxx3/7DkVFOdl8Mgb+yyKLPYkgZE41iyq5O6r6qgszEZhVBLffVVdXHqwSAIjRv7Q2MbRnn5uXlFtdSindP15M8nNsPPga9bM8RUi2Q2EwjzX2Man5pXhyE6f1HNVTc9hodORMuNU3b4AeZlp5GYm1ha6eIs0O2yWZociyiK9VeosqsCYX+HApuS9LUS8NBzoZOv+Tr68soa0E7ZRZKXbuf68mbz8oYe9Hd0WRRhbksBILGsWVbLpzovZd88VbLrz4rg1kJUERgxERqeeWZbH8lmJMTp1NI7sdL543hn8sekQB4+mRtm6EPH06s4Ojvb0c1WU/tK+vG4GTS5vSvz/2OGf2iNUIwqy0qmVZociBppcXrLSbcwpjW8Dz4jsDDtnluVLBYYQcfLw6/soyErjmiVVI97/N8tmkmG38dimlvgGFgf9g2EOd/dTViDriqlOEhgxsHV/J9vbfNy0oiahRqeO5svn16AgpUvOhIiV3ze0UpSbwQVnlkTl+S43t6GkQjNPjz8wpUeoDlfndNAsW0hElDW3djG/wnHSldh4Mhp5dqV040AhEsHBo728uO0QXzxvJnmjVDaW5Gdy5TkV/PZdF129qdV3qaPb2JZaLhUYU54kMGJg7aYWHNnprFlUYXUoYzLDkc2V51Ty6y0HpcmcEOPg7RvgpR1uPrOwImodsaum51BX6eD55vaoPJ+V3L6glHqa6iodHPIG8Pil2aGIjsFQmG2tPuoqrdk+ElHvLKSzdwBXZ+xH5wkxlT3yxj5sSnHTaban37Kqhr6BEE9tPhifwOKk3Wv8+ynrCiEJjChr6+rjT9sTc3Tqqdx2QS19AyF+9fZ+q0MRImm80HyI/sHwpKePnOjyuhk0HuzC1Zm820i01nj8AdlCYqp3Gk0Wt0kVhoiSPR099A2ELJtAErHQfG83Sh8MIWLG2zvAM1sP8tmFFZQ7Tv0B/qzyAlbOLuLxN1sYCIXjFGHsRaYdSQJDSAIjyn719n601vzNsplWhzIuc8vzuWhuCWvfbCEwELI6HCGSwrr3XMwuzYv6FdDL64xpJH/alrxVGP7gIIGBMKWyVxWA+RUFKIX0wRBR02QmDCLJMavMLc8nw24baigqhIi+Jzfvp7c/xFdW1Y7p/C+vrKHdF0iZpuAA7UMJDFlXTHWSwIiiwECIpzYf4FPzEnd06ql89cJZHOnp57fvuqwORYiEd/BoL1taOvncosqo97qZWZTL/IoCnk/ihYdcKTlebmYas0vy5EOeiJrmVi+5GXZqi3MtjSMjzcbZM/KlAkOIGOkfDPP4my2cP7uYeRUFY3rMRXNLqS3O5dE39qVMfxq3L0i6XTE9N8PqUITFJIERRc+930Zn7wA3raixOpQJOa9mOgurCnno9b2Ewqnxl50QsfL7hlaAmI2MurxuBg0HumjrSs595R6f0WxLmngeU+d00NTqTZnFpLBWo8vLgkoHNpv1zcLrnYVsa/URlrWDEFH3h8Y23L4gX1k19s8XNpvi5pXVNLq8vLu/M4bRxY/bF6A0PyspBiSI2JIERpRorXnszRbOKs9nWe10q8OZEKUUX7uglv1HetmwPXlL10VsrG9oZeU9G6m583lW3rOR9eYH+KlIa82691wsry2isjA7Jq9xbBpJcv6/6PEbCYzSfKnAiFjoLKTDH8RtJneEmKj+wTA7Dvks738RUe900B0cZO/hbqtDESKlaK156PW9zC3L58JxTjv7/MecOLLTU2bKoNsXOG3/DzE1SAIjSjbvO8qOQz5uWlGd1JnBS+aXU12Uwy9f3SNXCcWQ9Q2t3LWumdauPjTQ2tXHXeuap2wSo+FgFy1HevlclJt3DldTnMvZMwqSdv9qZNqG7FU9ps78sCml9mKyPnL76R8MW97/ImJhlRGH9HgRIrre2H2YD9v93LKqZtyfL3Iy0rhu6Rls2N7OwaPJ2xQ8ot0XkBGqApAERtSsfbOFwpx0rjwndh9o4sFuU9x6QS2NLi/v7DtqdTgiQdy7YSd9JzR37RsIce+GnRZFZK1177nISrdx2YLymL7O5QvKeXd/59DosGTi9gXJTrePOqt+Kpo3owC7TUkfDDFpzeY0m0SpwJhVkkdOhl0SGEJE2UOv76MkP5Mrz6mY0ONvXDETm1KsfbMluoFZwOMLSmNwAUgCIypau/rYsL2da5ecQXaG3epwJu3z5zopys3gl6/usToUkSBG68OQrP0ZJqN/MMwfmw5xybxy8rPSY/pal9dHtpEkXxWGx28sNJK5Ii3astLtnFmWT5OMUhWT1OTqoiArjTMSpGG43aZYUOGQ6iIhoujDdh+vfdTBTSuqyUyb2OeLGY5sLq+bwa+3HMQfGIhyhPHTHRykOzgoFRgCkATGpER6Aqy8ZyNhnTql0lnpdm5aUc0rOzv4sN1ndTgiAYy257AiRv0fEtkrOz109Q7EdPtIxKySPOaW5fNic/L1wfD4ApRJ/4uT1Fc6aHZ1yRY9MSlNLi/1zsKEShDWOx180OZjIBS2OhQhUsLDr+8jO93O9eedMannueX8GrqDg/xma/JOGXTLZDMxjCQwJmh4T4CIf/vTzpTpCfCl5TPJTrfz4Gt7rQ5FJIB5M04e25VuV9yxeq4F0Vhr3XsuivMyWTW7OC6vd3ndDLbsPzo0ljRZePxBSlIkqRtNdU4Hnb0DuDqnXvWSiI7AQIid7f6E2T4SUV9VSHAwzEduv9WhCJH0PL4Az77fytWLnRTmTG5s6MKqQhbPnMZjb+5L2imDbq8kMMQxksCYoFTvCVCYk8G1S6t47v22KblNQBzj8QfYtOcwi2cWUlmYjQIy7DbQjHkeearo6u1n44cerjyngjR7fP76vKK+HK2TbxqJxxegVEaoniTyobNZtpGICdpxyMdgWCdeAqPSiEf6YAgxeWvfbGEwrLnl/LGPTj2VW86v4eDRPl76wB2V54s3tzQGF8NIAmOCpkJPgFvOr0EDj6bI+CUxMf/51z0MhDT/fvU5bLrzYvbdcwVv/NNFOHLS+caT79ETHLQ6xLj5Y9MhBkKaq+KwfSRidmk+c0rzkmoaSXdwkJ7+kFwpGcHc8nzS7Uo+5IkJiyS/6hJkAknEzKIcHNnpNEkfDCEmpbd/kCffOcDqeeXMLMqNynNeMr8c57TspF3Tt3uN8eOyrhAgCYwJG23vfyr1BHBOy+Ez9TN4avMBvH3J2/hHTFxbVx9Pvn2Aqz/mpLr42D+ipQVZ3H/tIvZ0dPO/ft88Zfbzr3vPxdyy/BG31MTS5XUz2NxydGg0aaKLbHeRCoyTZabZOau8gOZW+ZAnJqbJ5aUoN4OKUXoTWUUpRb3TQeNBSc6JcTh0CC68ENrjUGUYz9eahN9sdeHtG+DWC6JTfQFGo92bVlSzueVoUk7CcvsC5GemkSuTzQSSwJiwO1bPJTv9+I7A2en2lOsJcNsFs+jpD/HkO/utDkVY4Kev7AbgW5+Yc9J9K2YX83efPJP177fx9JaD8Q4t7loO9/DegS4+d25l3BvnXVE/A61hQ5JsI/H4jSslpdLEc0R1TgdNLu+USfyJ6Gp2eal3OhKqgWdEvdPBTrefwAlbbIUY1fe+B2+8YXxNpdeaoFBY88gb+1h0RiEfmzk9qs99zZIqcjPsPPJG8vW3c/sClCVY0lZYRxIYE7RmUSV3X1U31BOgsjCbu6+qY82i+JWWx8O8igJWzSnmsU0tsiCZYg4c6eWZLQe5bmkVlaNUFn3zotmsmlPMd5/bzva25Mvoj8e6hlaUgjXnxP//8TmlecwqyeWFJJlGMpTAkL2qI1rodOAPDNJypNfqUESS6e0fZJfHn3DbRyLqnYWEwpoPDskEMzEGhw7BY49BOAwPPwyPPw7PPWfc3nrr2HkvvXTseOS2Zcux+1988eT7GxqO3f+HP8DatfDII8ZrPfLIscdrDUeOQF+f8X00f7cJVHv8eXs7B472ctuq2qi/VkFWOtcsqeKPTYdo9yZHRWeE2xeQ/hdiiNThTMKaRZUpl7AYydcunMX1D7/D+oZWrl06uVFOInnc9/Iu7DbF7RfNHvUcm03xk//vHK64/w1uf/I9nvvW+RRkpccxyvjQWhtjk2cVjzpSNpaUUlxRN4OfvrKbw91BivMS+x/xyBYSGaM6srpK48Nnk6uLmuLo7G8WU8P2Nh9hfaxhZqKJNBZtOtjFuWdMszgakfC+9z0joQDQ3w833XTsvksugQ0bjO+/8hU4cOD4x37+8/Db3xrfX389dHYef/9NNxnJkci5A8O2QgeDcMst0NRkfF9sThWz2SAnB3Jz4R/+Ae64A7xeuOoq41jklpMDa9bAxReDzwdPP33seOSchx82qj3+5V/gW986+XevqoLCQujuhn3H+lJseLqBjwcHuKQqxzjg88H+Eaqga2ogLw+6uuA734HXX4d/+if40Y8gO9u4jVCldfOKGta+2cITb7Xwj5eedfLznsqhQ3DttfDrX0N5+fgeO14nvJbbF+S82uhWpIz2WjEVr9dKxd9pGElgiNNaMauIBZUFPPjaXq5ZXIXNlnhlqyK6dnu6+X2Di1vOr6H0NA2TivIyeeCLi7j2wbe583dN/OyL5yZkafNkvLu/kwNHe/nOJ0/eShMvl9XN4P6Nu9mwvZ3rz5tpWRxj4fEHyUizUZAt/8SMZE5ZHplpNppdXq60oKJHJK9I89dEm0ASUV6QRUl+pjSpFacXqb7o7z92LDPTqJ4oLob8/GPHn3/++PPA+PAf8corEDqhSnj6sA+7f/wjfPazRrIi4qOPjIqFadPgvvugp8e49fYaX+eY/97390MgAEePHjunpwdmzzYSGK2t8NWvnvz7pacbyZknnoCHHjr5/v/+b7juOqMS5OKLhw7/JPLNJ8rg05+GV181Yj/RX/9qVF08+SQ884xx7IknjBsYz7t4sfHznXcOJTXOyMriz/4Q3wr+A9+6eA7Zf9kAv/nNsaRH5Pbtbxt/Bo2N8OGHkJVlJGVefx2+9jVYt85I+OzeDW1tx8emFKxaZXy/cye4T5h8kpYGK1YY33/wARw+fPz9mZlGNc4bb8B3vkP49m9SueM9FmVWwtsBI1FUX3/sz7Gnx3hNm834mpsLtWYFS0uL8Weo1LFzcnKOfdA+dMhI/Lz+uvHf6Qc/MH7XyPunvf1Yki0iO9t438DJvzsYz19YaFT0HDqhAftddx3bxvTTnx777xVtw7dL/exn0X9+q17LJKtLcVpKKb56wSy+9VQDL+1ws3p+fLJrwjo/+ctHZKXb+dqFs8Z0/pLq6fzj6rnc/eKHPP5mCzetjF7jqUTwu/dayU63W/reP6s8n9riXF5oPpT4CQxzhGqqJbKiJd1uY15FAU0ySlWMU7Ori/KCrNMmlq2ilGKh00GjTCIRpzO8+iJCa3j22ZM/BC1YcOrnWrjw1PevX3/y9hCtj33g+va3R39sSQls2jT6/XPmgMt1fHLjnnuMbS+R11m9Gm699fjHLV1qfJ0/f6iS5Jev7mGn288PPldH1sc+Zty/ePGxSpPh5s0zvr79tpEQGBwEux2WLYPPfAbOMCumZ86EK64wtsiYt7IMP0f6Nb97z8XfHDgAL7983P2Ew0ZSJj/fuKp+993Hv/azzxoVMdXVcP/98MADx9+flnas4uWHPzxWCRMxbZqREAL47ndP/v0qKoz7w2H4zW+w/frXPAPwxLDffft24/ubbjp+uxHAeecZ/13A+G+xbdvx93/yk8f+fJYuNf78wEiaPP44fO5zRoIGoK7u5ATLl750LFFUW3t8YgzgG98w3leDg1A5ykWKxx4zKnPmzTMSJllZRuImK8uo/PnGN4zEzzXXnHz/DTcYv4Pbbfy3H35fVpbxnMO3Zi1ZcizhAsbPFRXG4yP/nYZbvhxKS43k3NatJ9+/apWR4Im8dyJbsx57DP75n+NShSEJDDEmly0op2p6Nr94dQ+XzCuTDyYpbMchH39sOsQ3L5pN0Ti2Kty6qpYtLUf5/gs7WFhVyKIUKR8ODIR4vqmNSxeUW9r9WinF5XUz+Plfd3OkOziuP5t4c/uCMursNOr/X3v3HR5VlT5w/HsmPSGNloQkkNBBQhNFARuKFNdefquuFdvuul0su5ZdXXctq9tcFQuLa9t1LdhQYEHpihRJkE4CJCEkgZBCkskkM+f3x51J75mZOzN5P88zTyb3zsw9ZzJJzn3ve96THMu7W/KwOzRBktUmOikzr4wMH82+cBmfEsfK3UVUWGuJDsAphcJNNm5smVVhs8GGDf51rODgpiepBQXGSZ3reDYbrFlj1OBo7cRu4EC48koOHa/kic1f8sNbhhHeeGpHUpIxBaY1BQXGyX+dczl7ux22bjW2DRxobDvnHOPWSLTWJD63nkXrc7juF3diueuuhp1aG8GHEOfv7q9+ZZywP/ywEbiorTX6/OST8MILcPfdxnSaxhqfIyxYAD/4Qcv3zOXhh+GHP2y6/+9/h6VLjftBQZSffyF3x53JT2cOZ8qQeCPDwuXJJ40aJlobN4ej6cn6k08a04tc+7Vu+nMYM8Z4H+12IwA0Y4aRYeLyzDNGBk5jIxpl4/7jHy2zf1zBpaAgWLiwYfubbxrBMLvduD3zDPzmN8br19Q0fE1JMR5vtxvvZXk5FBU1POb88439R48aGSPNg3MzZzYnSQGkAAAgAElEQVSdmnXLLU33v/eeMS1q27aWPzuA5cth1izj9+Oaa1ru37jRCJStXAm33tqw3W73WhaGBDBEpwQHWbj9rKE8/OF3bD50gtPSPDQPTZju2RV7iQ4P5vauFJDCqIfxzNUTuejva7n7rW18+tMZxEWGeqiV3rNqdxHl1jqumGx+qv/cjESe+2I/y3cWcq0P16MpqrAyMiG64wf2Yhkpcby28RA5x04yfKC8V6Jj5dZaso9VcrmP197KSIlFa9iRX86Zw/qZ3RzhqxoX2QykY7WWWdKJE7tF63IItihumpbm8WMppZg/I52f/+dbVu8t5rzRAxvvhNBGY7d+/YyT4E8+aciqqKszMhUeeQRGjjRubRkzxri1JSOj6fcFBfD55w0BoNpaotZ8ya7brido3lxofnHMNVWlLfPmtb2voMCYOuIKQNjtsGlTw/QUMLId2jN/ftv7LBa4446GY/3sZw3HstmMgEZ2dtsZC4MGGVOF2jJhgvF6dXUNwY3Dh2H69JZTsz7+uKHWS7ozS3raNCPg1dwwZ/b1BRe0vt/18z79dOO1XRkoNpvXsjBkFRLRaVefmkp8ZAgLV/vf8kuic7bnlrJiZyF3nDWU2MhWrpx1UOk6NjKEf1w3maIKK796ZzsORzcrevvQWu3vb80nISaMacP6m90UxibFkNYvkqVZBR0/2ERFFTUMjPbdDBFfUF/sUGoFiE7a4ZxyND7VN1cgcZmQ0lCkVohepxvZHqVVNt7ZnMelE5O7lr3Yg8ySeRlJJMSE8eq6nA4f226gxN1aO5bDwU82vO3+zE6z++WOYyllZMv06WMEKF55pfWpWUuWwKRJxs1VPyYmpmFb41tMjLE/Pr71/a4MmH/8o2X2h6fev2YkgCE6LSI0iBvPTON/uwrZX1RhdnOEBzyzYi/xkSHcMqONGhadWEN9QmocD140lpW7i3hpbTeDXd5cq72dYElJpY0v9xRx2cRk96T59zAwo5RibkYSGw4c50Slrf0HeysI1Ow41TY7FdY6z8zR92Zgy8PHGjagDxEhQRLAEJ2W5fysZPjoCiQufaNCSYmPkM+26J22bWs6XcF1aycL5M2vD1Nda+e2s7pYP6wbx3IJDbZw45lprNt/jN1HO1j22OTpPkG1Nk7N380Ad18YCZRpTGYcx9vHakYCGKJLbjxzCOEhFl5aI1kYgWZTTglr9hbzw3OH0ae1Wg8FBQ2Fel580UjLu+IK41ZUZDzGOa/uxj/9kiUrnyH9jhsomf09qHAGvN54o+E5jW+utMSXXzZed+FC4zgLFxpzL10++sgojvXXv8JLL8HrrxtzMl327TP+ce/ebSw7VlRkLFHWnnaCJR9vP0KdQ3O5u6aPuCEwc1FGEnaHZvnODk6svRUEanacogpjrqhHMjC8Gdjy8LGCLIpxyTFk5ZcFVGBGeE5mXhkp8RH0jfL9qXkTUuKkkKcQnVBTZ2fxhoOcNaI/oxNjvHrs66cOJjzEwqKOsjB6ECjpslaO9cB727npJwsJCXLzaavJ/fLIsQKxT62QGhiiS/r1CeOaKam8vekwv7pwlBTqCxBaa/60fA8DosO44Yy01h/UOP3N4YCvv24oXOUqIFVSAvv3o4AMrYkur+L49qPo8mr6RUcbhZb272+7IcXFxuu6jmO3Nw1QvPOOMWewsQED4NJLjfsLFjR9PBhz/bKdAbfLLjMixhERRqXm4GAj2OGqnlxRAbm59U+dnF/GX5KGMfqJi4wNN97YZD9gVLt+4gnj/tVXt6xWfd55RpGqgoKGwMyLL8K33xpzBy+6yCiSBca691o3LPcFRoDnzjuNyuBXXskpwNs5JUQsDTLmgl57LVx/vVGk6uabjefU1BgVtl0VqB96yLj/4x+3fM/vvBPmzIEDB+Cee1ru//nPjRPeHTuM12nMajWWr3M4jODW3r3EOiz88+BxJmyIhYhgeOopY57mqlUNnyFXoS2HAxYtgtGjjfTGxx9vuf+jj4xK53/5i/G+aW0UDlu2zPj5rV4NCQnGcmSuJcka27zZSK1srRI6wK5dxnv9yCNGtXUwPs/Z2caxXPM5X3vNmCvrqvIdEWGka7qqs7/3nhE0c+1zLcM2e7axf/du4+fien54OJP7hvBa1jEcv3sUSwAvdybcIzO/1GeXT20uIyWWT7MKKKm0+UXARQizfPjtEYoranj2mg5WUvGAuMhQrpycwn+35HHvnNH099Hi4EfLrCTG+mbbhDkkgCG67LYZQ3njq0MsWp/DA3PbKcwj/Mb6/cfZlFPC7y45hYjQoJYPcK3X7gpUgHFCvXx500I9t99ev1RYEFBzpJzLnl/P6Z/l8NqtAwj62c+MIkZtueWWlle86+qMq8WJiQ3rqTde7qtxmx58EG66yTixdu2PiGjYf/75RkVv176vv26Yv2e3Gye7AwYY3au1U2WtZcSAyIbnu06sG2s8/8910t3a/scea7ivNeTkGIWSGre/srIhgu16XHV1w/1jx1Bak2a3cqzUSl2wlWBXdktdnVG8SWtjSbDGQaDHHoN7720I5DTmer7N1vp+VwaL1dpyf15eQ0Eqh8OIuick07eqmoiTgK3RUmqu904pozK3a712V6AmPNyomu5ap92131WtfPly43tXgAdg4sSGSumJicb3zVmcV2ySk1vf75Ka2rB/8+aGY7nev759jc9hdbXxXlitxvxQVwDj1Vfhs8+avuaoUUbgAoxCXmvXNtn9wzHjeX/mPUZ1eocDnn/eCHK5+nfuuQ1LvY0ebQSZGrv44oal3pKTGzKhXK67zgi8gDGntarKuO/l5c5Ez52otJFbUu3zSyi7NNR4KeXcUQM7eLQQvZPWmlfX5jA6MZoZw82ps3XL9HTe/Powb351mJ9dMKLjJ5igsLyGpFi5YCoaKN28+EaAmzJlit7c2pq2okvufmsrq/cUs+GBmbJMmp/TWnP58xsoKrfyxYJzCQtuJYDxox8ZJ2iN57qFhsJtt3V4Ffffmw5z//tZ/OKCkR3/c+zBcbqsoMBYv7vx8lgREfUVof+0bA/Pf7mfrx44v+f1HDo4Vldl5pVyyXPreeqq8VwzJdWjx2pTG8d5++0veWBjMVsfmuW+K6/e6lNPjmWzNQ1uuAJPo53L4W3YYKy53ugxhUERLH/xv1z33UqCam1GYGfCBCMjBox2uCqcP/OMkeHU2JgxDcvT/eEPRgCssQkTGpZA++1vjSrkmZlGsMvNv1dKqS1a6ylueTE/441xxZq9xdy4aBNv3TaVaSad6HRFhbWW8b9bzi8uGMlPz/fNkyIhzLZ6bzE3LdrEn66ewFWnppjWjpv/uYkd+eWsv/+81seAJjv1sRXMHpfIHy7P6PjBIqC0NbaQDAzRLXeePYxPMgt4e9Nh7jh7mNnNET2wancR3+aW8sQVGW3/4+pBoZ7/Oy2VTQdL+MvKvUxJi2d6e4NvbxYEaqcitOPvz/HBtnxmjBjgnmKU3VzqrC0ZybGkxEewNKugZQDDzcdqUxvHGfnyXwiZ8APiW1vFxs3H8sg0iO4eKzTUuMW2keI/bVqLTQPyj3D13XcRVGdrOM6uXfDppy2DJa5pRm359a/b33/nncY0GlfGjxeXOxM951rR4xQfL+DpEh0ewtD+UbISiRDteHlNNgkxYVwyYZCp7Zg/I50bXt3ER98e4ermYwqT2eocHK+0kRAtGRiigRTxFN2SkRLLtGH9eHVdDrY6R8dPED7J4dA8s3wvQ/pFcmV70f8eFOpRSvH7y8YxfEAffvbvbRSWW9t+sDcLArUTLNl0sIT80mqudFfxTjcHZpRSzMtIYv3+Y5RV1Xr0WG1q4zgJO7YyMDocpdywaksHx/L3qtqWx39PkLeWIPPmcnHC7TLzykjvH0VshP9kPE5IiZOVSIRow84j5azbf4ybpqURGmzu6diM4f0ZlRDNq+ty8LXMfFdhcKmBIRqTAIbotjvPGUZheQ0ffptvdlNEN33+3VF2FpTz8wtGuL+6cyORocG88IPJVNbY+clb26iz+0DQq51gyQdb84kKDeLCsW66Mu2BwMy8jCRq7ZoVuwo9fqxWtXGc+x98zf1LnQVqVe2NGwmxNwtABUBgRrhfVn6Z3xTwdMlIiaWoooajZe0ErYXopV5Zl01kaBDXn25+XRulFLfOSGP30Qo2HjhudnOaKCyvAfDM0uzCb5kSwFBKHVRKZSmlvlVKbXZu66uUWqGU2uf8Gu/crpRSf1NK7VdKZSqlJjd6nZucj9+nlLrJjL70ZmeP6M/oxGheWpONw+FbEVvRMbtD8+yKvQwf2IdLJrgp06AdwwdG84crxrHpYAnPrNjr8eN1l7XWztKsAuZmJLVe0NRHTEiJJTkugs+yCsxuShNFFVbPLKEagJYs+oQRv/6UtPs+qb+NefAzliz6xP0HM3G5M9EzRRVWCsqsZPjJ9BGX8SlxALKcqhDNHC2z8tG3R7hmSiqx7pxu2QOXTkymX1Qor3a0pKqXubJ2EyWAIRoxMwPjPK31xEaFOe4HVmqtRwArnd8DzAVGOG93AC+AEfAAHgGmAqcDj7iCHsI7lFLcdc4w9hWd5Is9RR0/QfiUj7bns7/oJL+cNZIgixvT/dtx+aQUrj19MC98eYBVuws7foIJVuwspKKmjismeT6o0xNKKeaOS2TtvmOUW2s7foKXFFXUyPLKnfT0sj3U2psGf6tr7Ty9bI9JLRK+KMs5DcMVEPAXpwyKIdiipA6GEM0s3nAQh9bcOj3d7KbUCw8J4vozhrBydxHZxSfNbk49VwBDxhWiMV+aQnIp4FzvjdeAyxpt/5c2fAXEKaWSgNnACq11idb6BLACmOPtRvd2F41PIjkugoWrW1l+UfisWruDv/xvH2OTYphzincL+D1y8VjGJsXwi/9sJ+9ElVeP3RkfbMsnKTacM4b2M7spHZo3Pgmb3cH/dvpGMMhaa6e0qlYyMDrpSGl1q9vzS6vJLj7pc3ORfYFSapFSqkgptaPRNrdlcCqlTnVmiO53Ptc70d12ZOaVYVFGQMCfhIcEMTIhWupgCNHIyZo63vr6EHPGJTK4X2THT/CiG84YQmiQhX+uP2h2U+odLbcSGmRxb2Fw4ffMCmBoYLlSaotS6g7ntgStdQGA86tr4fBkILfRc/Oc29raLrwoJMjC/BnpbDpYwtbDJ8xujuik97bkceh4Fb+6cCQWL2VfuISHBPH89ZOxOzR3v7XNp4rAFlfUsHpvMZdNSvb6+9IdE1PiSIoNZ2nWUbObAhjvH8DAGAlgdMaguIg29818ZjXnPP0lDy3ZwcpdhVTZ6rzYMp+2mJYXK9yZwfmC87Gu55l+YSQrv4zhA/sQFeZ/C8eNT4klM69MgnFCOL3zTS7l1jpuO2uo2U1pYUB0GJdMHMS7W/IorbJ1/AQvKCyzMjAmzL2FwYXfMyuAMV1rPRljcPFjpdTZ7Ty2tU+sbmd7yxdQ6g6l1Gal1Obi4uKut1a06/9OSyU2IoSXJAvDL9TU2fnbyn1MTI1j5uiBHT/BA9L6R/H0VeON5Vs/221KG1rz8fYj2B3a56ePuFgsirnjklizr5gKH5hGUlQhxba6YsHsUUSENK2zEhESxEPfG8Njl41jZEIf3t2Sx/zXNjPx0RXc8OrXvLI2m/1FvTc7Q2u9BihpttktGZzOfTFa643aeIP/1ei1TKG1JjOvlIxk/5o+4jI+JY6y6loOl/hetp0Q3lZnd7BofQ5ThsQzebBvznq/dXo61bV23t6U2/GDvaCwvEbqX4gWTAlgaK2POL8WAR9gXAEpdA4ecH51FVXIAxovSpwCHGlne2vHe0lrPUVrPWXAgAHu7IoAosKCueGMISzbedSn5s2J1v17Uy5Hyqzcc+EoUyPaczOSuGV6GovW5/D5Dt8oRPnBtnwykmMZkRBtdlM6bV5GIrY6Byt3mV+Hpsg5V1WmkHTOZZOS+eMVGSTHRaCA5LgI/nhFBvNnDOWGM4bwyk2n8e0js3hj/lRuPGMIBWVWfv/pLi54djVnPfUFv/kgixU7C6ms6fXZGe7K4Ex23m++3TQFZVaOnbT53QokLq52b5dpJEKw7LtC8k5U+2T2hcvYQTFMG9aP1zYcpNYHVowrLLdK/QvRgtcDGEqpKKVUtOs+cCGwA/gIcM1DvQn40Hn/I+BG51zWM4Ay5wBlGXChUiremfp5oXObMMFN09IICbLw8lrfql4smqq22Xnui/1MTe/L9OHm13h4YO4YJqTGseC/mRw8VmlqW/YVVpCVX8blfpJ94TJ5cDyJMeEs9YHVSOozMKJlsNFZl01KZv39M8l54iLW3z+Ty5p9/sKCg5gxoj8Pfm8s//vlOay77zwev3wcY5JiWLItn9v/tZlJj67g+le+4uU12ewrrOi12Rmt6GoGp89ldrrqR2T4aQBjVGI0YcEWMnOlkKfo3bTWvLQ2myH9Ipk1NsHs5rRr/ox0jpZbfWJcIQEM0RozMjASgHVKqe3AJuBTrfXnwBPALKXUPmCW83uApUA2sB94GfgRgNa6BHgM+MZ5e9S5TZhgQHQYV52awntb8yiqkDXffdXrXx2kuKKGX5mcfeESGmzhH9dNwmJR/OjNrVhr7aa15f1t+QRZFJdMHGRaG7rDYlHMGZfIl3uLOWnylfiiCitBFkW/qFBT2xHIUuIjuX7qEF6+cQrbHr6Qt26bys3T0yiuqOHxpbuY9ec1zHjyCx54P4tl3x1t8plYsi2f6U+sIv3+T5n+xCqWbMs3sSdu5a4Mzjzn/ebbW/BWZmdWfinBFsXYJP8q4OkSEmRh7KAYMvMlA0P0bpsPnWB7bim3zUj32spv3XXeqIGk949i0bocUwPiFdZaKm12EqSulmjG6wEMrXW21nqC83aK1vpx5/bjWuvztdYjnF9LnNu11vrHWuthWusMrfXmRq+1SGs93Hn7p7f7Ipq6/ayh1NodvLbhoNlNEa04WVPHC18e4OyRAzg9va/ZzamXEh/Js9dMYGdBOY9+stOUNjgcmiXb8jln5AD69/G/f5TzMpKw1TlYtdvcaSSF5TUM6BPmFwVQA0FosIVpw/vz63ljWP6Lc9hw/0z+eEUG45Jj+Hj7Ee58fQuTHl3OtS99xU/e2sp972WSX1qNxljp5IH3swIliOGWDE7nvgql1BnO1UdubPRapsjMK2NkQjThzWql+JPxybHsyC/D7pDMINF7vbwmm7jIEK46NbXjB5vMYlHcMj2N7XllbDlkXoH+wnIjqzMxVjIwRFO+tIyq8HPp/aOYc0oir288ZPqVYNHSP9flcKKqll/NGml2U1o4f0wCd50zjLe+PmzKCdVX2ccpKLP63fQRlylD4hkYHcbSTHPTPYsqamQFEhMNiovg2tMHs/CGKWx9aBZv334G82cM5USVjY8zC6hptuJPda2dp5ftMam13aOUehvYCIxSSuUppebj3gzOHwKvOJ9zAPjMG/1qjVHAs8xv61+4jE+Jo8pm54DUyBK9VM6xSlbsKuQHU4cQEeofwcgrJ6cQEx7Mq+vMmxpe6KyrJVNIRHP+tyaX8Gl3nD2Uz3Yc5d+bDvt0kaLepqyqlpfWZjNrbAITUn2zmv09F45k66ETLHh3O39YuoviihoGxUWwYPaoFnUB3GXJtnyeXraH/NJqFJg6haUnjNVIEvn3N7lU1tSZttxiUbmVlPi2lwYV3hMabOHMYf04c1g/7p87mvT7P221mMOR0mqvt60ntNbXtrHr/FYeq4Eft/E6i4BFrWzfDIzrSRvdJbekmrLqWr+tf+EyIdVZyDO3lJF+VCBZCHd5dV02IRYLN04bYnZTOi0qLJhrpw7m5TXZ5JZUkdo30uttkACGaItkYAi3mjQ4nqnpfVm0LscnqhcLw8trs6mw1vFLH8y+cAkOsjBvfCK1dk1RRY3H09yXbMvngfezyHeewGng4Q+/89uU+rkZSdTUOfhij3nTSIwMDBlo+KJBca0HltraLsyXmW8UvpyQ4ptB584a2r8PUaFB9QVJhehNTlTaeHdLHpdNGuR3Ba5vOjMNpZRpU8OP1gcwJLNTNCUZGMLt7jxnKLcu3swnmUe4fFJKx08QHnX8ZA2L1ufwvfFJjPHxQnAvr2mZqlhda+e3H3/n9oDY40t3Ud0s48KVUu+pjA9POi2tL/37hLE0q4Dvjfd+IVJbnYOSSpssoeqjFswexQPvZzX5zEeEBLFg9igTWyXak5lXRmiQxe+zFiwWxbjkWCnkKXqlN746hLXW4ZdZyYPiIpiXkcR/vsnl57NG0sfL2Z1F5TVEhwcTGSqnq6Ip+UQItzt35EBGJvRh4epsLpuY7BOrXfRmL64+gLXWzs8v8N3sC5e20tlLq2pZ8G6mqW3wdUEWxZxxCby3JZ8qW53X/+EfOylLqPoyV1Du6WV7OFJa7fHpWaLnMvNKGZMUTWiw/yfLTkiNY/H6g9jqHAHRHyE6w1pr57WNBzln5AC/DUTOn5HOx9uP8M43udw6I92rxz5aZiVRsjpFKySAIdzOYlHccfYw7vnvdlbvLebcUQPNblKvVVhu5V8bD3H5pBSGD+xjdnM6NCguon5KR2MJMWG8e9c0tx7rqhc31Fe4bt4GfzUvI4k3vjrMl3uKmZeR5NVjF0qqp8+7bFKyBCz8hMOh2ZFf7reFhZsbnxKLze5gz9EKv6/pIURnffhtPsdO2rjjbP/LvnCZmBrHqUPi+eeGHG6alubVJWALK6xS/0K0SsLgwiMumTCIxJhwFq7ONrspvdo/vtiP3aH52fkjzG5KpyyYPYqIZssFRoQE8cDcMaT2jXTr7YG5Y1o9lj+n1E9N70e/qFA+zfL+aiRFFZKBIYS7ZB+r5GRNXcCc7LvqeGzPKzW5JUJ43pJt+Ux7YiX3vZdFsEVR5Azw+6v5M9LJLalmxc5Crx63sEwCGKJ1EsAQHhEabGH+jHQ2Zh9ne64MWMyQd6KKtzcd5prTUhncz/vVo7vjsknJ/PGKDJLjIlBAclwEf7wiwyNXjb15LG8Jsihmj0vki91FVNu8u6JKfQBDMjCE6LEsZwFPf19C1WXzwRIsCh5csoPpT6zy22LJQnTEVSD8SKkRtKhzaH79wQ6//sxfODaB5LgIFnlxSVWHwyjoLlmdojUyhUR4zPdPT+Vvq/bx0pps/nH9ZLOb0+v8feV+lFL8ZOZws5vSJd5Mcw/ElPqLMpJ46+vDrN5bxJxx3ptGUlRuxaKgX1So144pRCBasi2fB5fsAODWxd9w7+zRfv13asm2fH79wQ4cznV8XatLAX7dL+FfXMume6IGkLXWTkmljZJKG499sjOgCoSDsUrcaWnxLPn2COn3f+qVGkrHK23UOTSJsZKBIVqSAIbwmOjwEK6fOoSX1hzg0PFKhvSLMrtJvUbOsUre3ZrHjWcOISnWf2s6iK6bmt6XqNAgfvGf7fzwja1eK9ZYVF5Dvz5hBAdJYp8Q3eW6eus6ATpSavX7k/2nl+0JuBM64V+a/151FESrstVx/KStPihxvNJGSWWN8fVk423G7WRNXYdt8NcC4WC8f59/dxSgyRL34Lm/S666WjItVbRGAhjCo26ZnsaidTm8sjaHxy4bZ3Zzeo2//m8voUEWfnjuMLObIrzsk8wCrHUO7M7Lnd662llUYZUlVIXooUA82W/rxM2fT+iEf3lq2e5Wf68eXJLFmn3FDYGKkzaOV9ZgrW192fbQIAt9o0LpGxVKvz6hDOkXadyPCqVvVBh9o0J5cEkWx07aWjzXnwuEP71sT4v3pLrWzr3vZrLxwHGG9I8krV8UQ/pFMqRflFuWW3UFMCQDQ7RGAhjCoxJiwrl8UjLvbM7l5xeMoF8fOcHxtL2FFXy4/Qh3nj1MIte90NPL9tQHL1y8cQJUWF4jAw0heigQT/bbWl1KA88s38PdM4cTFhzU8olCdILDoTleaaOgrJojpVaOllVTUGZ13oz7rnoUzZ2ssfN1dkl9UGL4gD7G/T5NgxL9+xj7+4QFo1T7q3BYa+1Nsj3A/wuEt/X3x2Z3sHJ3Uf0y6i79+4SR3t8IZqT1c32NYkj/SGLCQzo83pJt+fz2o+8AuOv1zdw/d4zfBnCFZ0gAQ3jc7WcP5T+bc3lt4yF+OWukKW3w5NxHX/PnFXuJCg3mTj9etkt0n1knQEUVNQFTcFAIs7R1su/PV28XzB7V4oQuPMTCuEEx/H3VfpZ9d5SnrprAxNQ4E1vZPb1pbGEGh0NTUmWjoNTKkbJqjpY1fC0otVJQXk1hWQ02e9PsgNAgC4mx4STFhnNaWl9KqwpbneaRHBfB+vtnurXNrp9/IH0u2vq75Hr/Kqy1HDpexaHjVRw8Xsmh45UcPF7F2n3FvLulaXCjb5SRueLK2EjvH1Uf6IiLDG0x3edoeY3fT6MT7icBDOFxwwf2YdbYBP618SB3nTOUyFDvfuy6OvfRn+3IL+OzHUf52fkjiJdiir1SWwON4CDFxgPHOXNYP7cfs87u4HhljUwhEaKHWjvZ9/ert+2d0H2xu4gH3s/iiufXc/tZQ/nFrJGEh/hHNkZvGlt4gtaakkqbM0OimqPl1voMiiNlVo46b82DEyFByhmciGDy4HiSYiMYFBdOYkw4g+IiSIwNp19UaJNMieY/K/Ds71WgFQjv6O9SdHgI45JjGZfc8iJGla2OwyVVHDxWVR/YOHS8kq+zj/NBs5VZYiNCqLLVUWv3fhap8C8SwBBecdc5Q1mxs5B3vsnl5unpXj12IM4pbsuzK/YSGxHC/LO8+x4L39HaQCMkSBEZGsS1L3/FzNEDuXfOKEYnxrjtmMcrbWgNA2W9diF6JBCv3kLbJ3TnjR7I8l+ezR+X7mLhmmxW7CzkqavGMyWtrwmt7Jqn26ir8OjH3zFsQB9S+0YQGxHS4ZQDX+OOrBKtNSeqao3AhHMqhyso4QpWFJRZsdW1DE4kxIQzKDaCialxJOFGgBkAABU1SURBVGWEkxQTTlJcBINiG4ITFkvX3tNA/b3ylp68f5GhwYxOjGl1zGGttZNbUlUf1Dh4vJI3vjrc6uv48zQ64X4SwBBeceqQvkwZEs8r63L4wRlDvLpSQVt/9PJLq7lm4UZS4yNJ7RtBanwkg/tFkhofycDosC7/gzTblkMnWLW7iHvnjOrUHEMRmNoaaMwZl8jiDQf5xxf7mfvXtVw5OYVfzhrpltT0hmrhkoEhRE8F2tXbjsSEh/DHK8ZzUcYg7nsvk6sXbuSmM9O4d84or2dsdkad3cFnO46S30ZdhZKqWi5+bh0A0WHBpPSNZLBzjJHat2G8kRIfSURo57NNvDFdpTNZJVprSqtqG03psFJQ2mx6R5mVmmbBiWCLEZxIig1nfEocc04Jr8+kSIoNJykunP5Rnht79bbfK3fzxPsXHhLEiIRoRiRE12/7YndxwE2jE+7ne/8ZRMC64+yh3PH6FpbuOMolEwZ59FgOh2b1vmIWrctBt/GYiJAgtNas219MYXnTOXqhwRZS4iJI6RtJanyEMehoFOiIi2z7qopZc2KfXbGH/n1CuXlamsePJXxbWwONu84Zxv9NSeX5L/fz2oZDfLz9CDdPT+NH5w4nNqL7Qa8i5++PZGAIIbprxoj+LP/F2Tz1+W4WbzjIyt2FPHnleKYN62920wAjFf6db3J5ZV0OeSeqCbYo6hwtRxgDosN47NJTyC2pJvdEFbklVRwormT13uIWKzn07xNWP66ov5DS1wh0JMWG11/s8cR0Fa01NXUOrLV2rLXG1z8s3dVqVskD72fxn29ynZkT1S36EWRRJMYYAYlxybHMGpvQMLUjNoJBseH06xNGkJ9dGBLeF4jT6IT7SQBDeM0FYxIYOiCKhasPcPH4JI+kVVbZ6nh/az7/XJ/DgeJKBkaHcVFGIit3FzX5hxsREsQfr8io/8dvrbWTX1pNbkkVuSeqySupcg48qsnMK6W0qrbJcVxXVRqCG8bXvYUV/HXlvvpjeWtO7IYDx1i//zgPfW+sT16xEr4jPiqU31w0lpumpfHs8r28tCabf2/K5e7zhnPDmUO6Nf+8qMIIYCTESAaGEKL7osKC+d2l45iXkcR972Vy3ctfc/3Uwdw/dzTRJmUWHjtZw782HORfXx2itKqWU4fE89D3xlJlrePXS3a0ONH6zbwxzBmX1OJ1tNYUn6wht6SaPGdgwxXk2JZ7gk+zCpqsIBVkUSTFhpMaH8n2vNJWAwsPf7iD7OKTWOsDEQ3BCNe2Gte2uqb7m2dItKe61k5NnZ2xg2I4f/RAkuKcWROxRt2J/hKcEG4i031EZyit27o+HZimTJmiN2/ebHYzeq3/fHOY+97L4o35U5kxwn1XVY6WWXlt40He+vowZdW1ZCTHMn9GOvMykggNtvQ4K6LcWls/2KgfeJxwBTyq2lwz3CUqLIg7zx5GfFQofSNDiY8MMe5HhRIXGdLtJeSMfu0mv9SKRcGTV47n6imp3Xot0Tt9d6SMJz/fw5q9xSTHRXDP7JFcOiG5S2m8f16xl7+t2sfe388lxIvTw4TvUEpt0VpPMbsdZpBxhWdU2+w8s3wPr67PISkmnD9ckcG5owZ67fg5xyp5eW02723Jw2Z3MGtMAneeM5RThzTU53BnxmWd3UFBmbV+XNE4g2Pr4dJ2nxseYiE8JIjw4KD6+2EhQYQHO7e3tT/E4txm3H/sk52caHbBBjyzWocQQnSkrbGFBDCEV9XU2Znx5BeMTozm9flTe/x623NLeXVdDkuzCnBozYVjE5l/VjpThsR7rXCW1ppjJ23knqjiiuc3dOs1+oQFEx8VQnxkKPGRRmDD+GoEOppsdz7u08yCVtPsGmeWCNFZ6/cf44+f7WJHfjljk2K4f+5ozh45oFPPfeD9LJZ/d5QtD83ycCuFr5IAhowrPGXr4RMs+O92DhRXctWpKTx00VhiIz2XjbH18AleWp3Nsp1HCQmycOXkZG47ayjDBvTx2DE7Mv2JVa3XBYgNZ/39M9023mlrtQ4ZVwghzNDW2EJyzYVXhQUHcev0dJ78fDc78staXXKpI3V2B8t3FvLquhy2HDpBn7BgbpqWxs3T0kjtG+mBVrdPKcWA6DAGRIeR3M5a2V/ccy6l1TZOVNZSUmnjRJXzVmmjpLKWE1W2+u0Hik9SWlXb6rrl9ceFFvU9AnV1FeF504f356Mfz+DjzCM8vWwPNy7axIzh/bl/7ugOf0+LK6wMkAKeQggPmDw4nk9/ehZ/W7mPhWuyWbO3mMcvz2DW2AS3HcPh0KzaXcTCNQf45uAJYsKD+dG5w7hpWhoDo82v7dNWXYB754x268UaSd8XQvgDycAQXldWXcv0J1Yxc/RA/nbtpC49751vclm84SD5pdUM7hvJzdPSuHpKimlzY5tz99WLmjo7pVXOgEeljRJnwONEVS3Prtjb6nMUkPPERd3tghDU1Nl546vDPLdqHyeqarl04iDuuXBUmwHCi/++jr5Robx26+lebqnwFZKBIeMKb8jKK2PBu9vZfbSCSycO4pGLT6FvVGi3X6+mzs6Sbfm8tCabA8WVJMdFMH9GOv93WipRYb51jc+sAuFCCGEWycAQPiM2IoTrpg7m1XU5LJjd9kmRy8FjlSzecJB3NudSZbMzNb0vD188lgvGJPhc0Sh3X70ICw4iISaIhFZWd/jPN7my1JTwiLDgIObPSOfqKSm8+OUBFq03pmndcEYad88c3uKEoajCyujE6DZeTQgh3CMjJZaP7p7B81/u57lV+1m//xiPOot+dkVZdS1vfn2If64/SHFFDWOTYvjr9ycyLyPJZ+v4yDKgQghhkACGMMUt09NYtC6HV9fl8NtLTmmxX2vNxuzjLFpnLKUWbFFcPH4Qt85I79a0E2/y1iBDlpoSnhYTHsK9c0Zz45lp/HnFXhZvyOG/m3O569xh3Do9nYjQIOwOowbMQFmBRAjhBaHBFn5+wUhmn5LIgne386M3tzJ3XCKPXjquw6ls+aXVLFqXw783HabSZuesEf159poJzBje32t1s4QQQvSMTCERprn6hQ1sPnQCoD5TYW5GIh99e4RF6w+yq6CcvlGhXD91MDecMYSBrWQh9HaSUiq8aW9hBU99vpv/7SoiISaMc0cNYPWeYxwttxIbEcLvLjlFPn+9lEwhkXGFGersDhauyeav/9tHZFgQj1w8FjT8afneJv8XRyVG89KabD7efgQNXDw+idvPHsopg3z7gogQQvRmsgqJkww0fMOSbfnc915mk3XIgy2K8BALJ2vsjEzow63T07lsUjLhId1bYlQI4Rmbckq457/fcrik6RQmqVbfe0kAQ8YVZtpfVMGCdzPZdrgUiwJHo6Gt6/vI0CC+f9pgbp2RRkq89wt+CyGE6BqpgSF8ytPL9jQJXgDUOTS1ds3r80+XdE4hfNjp6X2xO1oGv2UVHCGEGYYPjObdu6Yx+bHllFU3Xb3LoSEmPJi198706PKrQgghvEMCGMIUR1opPglgq3Nw1ogBXm6NEKKrjpRa29je+u+2EEJ4UpBFUV7d+tLjFdY6CV4IIUSA8M1SyyLgtbVShqygIYR/kN9hIYSvkb9LQggR+CSAIUyxYPYoIprVtpAVNITwH/I7LITwNfJ3SQghAp9MIRGmcM2RlxU0hPBP8jsshPA18ndJCCECn6xCIoQQQogekVVIZFwhhBBCuFNbYwuZQiKEEEIIIYQQQgifJwEMIYQQQgghhBBC+DwJYAghhBBCCCGEEMLnSQBDCCGEEEIIIYQQPk8CGEIIIYQQQgghhPB5EsAQQgghhBBCCCGEz5MAhhBCCCGEEEIIIXyeBDCEEEIIIYQQQgjh8ySAIYQQQgghhBBCCJ+ntNZmt8GrlFLFwCE3v2x/4JibX9MXBGK/ArFPEJj9CsQ+QWD2KxD7BNKvrhiitR7g5tf0Cx4aV0Bgfv4CsU8QmP0KxD6B9MufBGKfIDD75ak+tTq26HUBDE9QSm3WWk8xux3uFoj9CsQ+QWD2KxD7BIHZr0DsE0i/hLkC8ecUiH2CwOxXIPYJpF/+JBD7BIHZL2/3SaaQCCGEEEIIIYQQwudJAEMIIYQQQgghhBA+TwIY7vGS2Q3wkEDsVyD2CQKzX4HYJwjMfgVin0D6JcwViD+nQOwTBGa/ArFPIP3yJ4HYJwjMfnm1T1IDQwghhBBCCCGEED5PMjCEEEIIIYQQQgjh8ySA0QlKqUVKqSKl1I5W9t2jlNJKqf7O75VS6m9Kqf1KqUyl1GTvt7hjXezT9c6+ZCqlNiilJni/xZ3TlX412n6aUsqulLrKey3tvK72SSl1rlLqW6XUd0qp1d5tbed18TMYq5T6WCm13dmvW7zf4s5prV9Kqd8qpfKdP5dvlVLzGu17wPn3Yo9SarY5rW5fV/qklJqllNqilMpyfp1pXsvb19WflXP/YKXUSaXUPd5vcce68fkbr5Ta6Py9ylJKhZvT8t4lEMcVIGOLZttlbGGCQBxbBOK4AgJzbBGI4wrwvbGFBDA6ZzEwp/lGpVQqMAs43GjzXGCE83YH8IIX2tcdi+l8n3KAc7TW44HH8O25W4vpfL9QSgUBTwLLvNG4blpMJ/uklIoDngcu0VqfAlztpTZ2x2I6/7P6MbBTaz0BOBd4RikV6oU2dsdiWukX8Get9UTnbSmAUmos8H3gFOdznnd+Jn3NYjrZJ4x1wC/WWmcANwGve6mN3bGYzverfh/wmcdb1n2L6fznLxh4A7jL+ffiXKDWWw3t5RYTeOMKkLGFa7uMLcyzmMAbWywm8MYVEJhji8UE3rgCfGxsIQGMTtBarwFKWtn1Z+BeoHEhkUuBf2nDV0CcUirJC83skq70SWu9QWt9wvntV0CK51vYPV38WQH8BHgPKPJw07qti326Dnhfa33Y+dxA6ZcGopVSCujjfF6dxxvZDe30qzWXAv/WWtdorXOA/cDpHmtcN3WlT1rrbVrrI85vvwPClVJhHmtcD3TxZ4VS6jIgG6NfPqmLfboQyNRab3c+97jW2u6xxol6gTiuABlbNCJjC5ME4tgiEMcVEJhji0AcV4DvjS0kgNFNSqlLgHzXD6eRZCC30fd5zm0+r50+NTYf348SNtFWv5RSycDlwIumNKwH2vlZjQTilVJfOlPsbjShed3WTr+eA8YAR4As4Gdaa4e329dDdztTpRcppeKd2/z274VTa31q7Epgm9a6xtsN66EW/VJKRQH3Ab8zt2nd1trPaiSglVLLlFJblVL3mtnA3i4QxxUgYwt/ImMLvxtbBOK4AgJzbBGI4wowaWwhAYxuUEpFAr8BHm5tdyvbfH6plw765HrMeRiDjPu81a6e6qBffwHu87crjh30KRg4FbgImA08pJQa6cXmdVsH/ZoNfAsMAiYCzymlYrzYvJ56ARiG0fYC4Bnndr/8e+HUVp8AUEqdgpFCfaf3m9YjbfXrdxipkifNalgPtNWnYGAGcL3z6+VKqfNNaWEvF4jjCpCxhXdb1TMytvC7sUUgjisgMMcWgTiuABPHFsHufLFeZBiQDmw3ss5IAbYqpU7HiHSmNnpsCkZk19e12Set9VGl1HjgFWCu1vq4ie3sqvZ+VlOAfzu39wfmKaXqtNZLzGpsJ3X0+Tumta4EKpVSa4AJwF6zGtsF7fXrFuAJbaz7vF8plQOMBjaZ1diu0FoXuu4rpV4GPnF+669/L9rrE0qpFOAD4Eat9QETmtdt7fRrKnCVUuopIA5wKKWsWuvnTGhml3Tw+VuttT7m3LcUmAys9HojRSCOK0DGFjK2MF9Aji0CcVwBgTm2CMRxBZg7tpAMjG7QWmdprQdqrdO01mkYP6jJWuujwEfAjcpwBlCmtS4ws72d0V6flFKDgfeBG7TW/vDPql57/dJapzfa/i7wIz8YYHT0+fsQOEspFey86jAV2GViczutg34dBs4HUEolAKMw5gz6BdV0vvrlgKuK80fA95VSYUqpdIwifT4/cIK2+6SMYm+fAg9ordeb0baeaKtfWuuzGn02/wL8wV8GGe18/pYB45VSkcoounUOsNPb7ROBOa4AGVsgYwvTBerYIhDHFRCYY4tAHFeAuWMLycDoBKXU2xgVVPsrpfKAR7TWr7bx8KXAPIyiOVUY0V2f08U+PQz0w6hkDFCntZ7ilYZ2URf75Re60iet9S6l1OdAJuAAXtFat1hKzBd08Wf1GLBYKZWFkR55nyuy62ta6xdwrlJqIkYa50GcqY9a6++UUu9g/GGvA37si2nHXekTcDcwHCPF+CHntgu1DxZ962K//EIXP38nlFLPAt849y3VWn9qRrt7m0AcV4CMLfyJjC0APxlbBOK4AgJzbBGI4wrwvbGFMrKmhBBCCCGEEEIIIXyXTCERQgghhBBCCCGEz5MAhhBCCCGEEEIIIXyeBDCEEEIIIYQQQgjh8ySAIYQQQgghhBBCCJ8nAQwhhBBCCCGEEEL4PAlgCCH8klLqS6WUTy65J4QQQgj/IuMKIfyDBDCEEEIIIYQQQgjh8ySAIYTwCqXUvUqpnzrv/1kptcp5/3yl1BtKqQuVUhuVUluVUv9VSvVx7j9VKbVaKbVFKbVMKZXU7HUtSqnXlFK/936vhBBCCGEGGVcI0TtJAEMI4S1rgLOc96cAfZRSIcAMIAt4ELhAaz0Z2Az80rn/78BVWutTgUXA441eMxh4E9irtX7QO90QQgghhA+QcYUQvVCw2Q0QQvQaW4BTlVLRQA2wFWPAcRbwETAWWK+UAggFNgKjgHHACuf2IKCg0WsuBN7RWjcefAghhBAi8Mm4QoheSAIYQgiv0FrXKqUOArcAG4BM4DxgGJADrNBaX9v4OUqpDOA7rfWZbbzsBuA8pdQzWmurxxovhBBCCJ8i4woheieZQiKE8KY1wD3Or2uBu4Bvga+A6Uqp4QBKqUil1EhgDzBAKXWmc3uIUuqURq/3KrAU+K9SSgKyQgghRO8i4wohehkJYAghvGktkARs1FoXAlZgrda6GLgZeFsplYkx8BittbYBVwFPKqW2YwxKpjV+Qa31sxhpo68rpeRvmhBCCNF7yLhCiF5Gaa3NboMQQgghhBBCCCFEuySqKIQQQgghhBBCCJ8nAQwhhBBCCCGEEEL4PAlgCCGEEEIIIYQQwudJAEMIIYQQQgghhBA+TwIYQgghhBBCCCGE8HkSwBBCCCGEEEIIIYTPkwCGEEIIIYQQQgghfJ4EMIQQQgghhBBCCOHz/h/98q11q0XWHQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x1080 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_samples = 6\n",
    "min_week = 140\n",
    "sales = pd.read_csv(os.path.join(DATA_DIR, \"yx.csv\"))\n",
    "sales[\"move\"] = sales.logmove.apply(lambda x: round(math.exp(x)) if x > 0 else 0)\n",
    "\n",
    "result_df[\"move\"] = result_df.predictions\n",
    "plot_predictions_with_history(\n",
    "    result_df,\n",
    "    sales,\n",
    "    grain1_unique_vals=store_list,\n",
    "    grain2_unique_vals=brand_list,\n",
    "    time_col_name=\"week\",\n",
    "    target_col_name=\"move\",\n",
    "    grain1_name=\"store\",\n",
    "    grain2_name=\"brand\",\n",
    "    min_timestep=min_week,\n",
    "    num_samples=num_samples,\n",
    "    predict_at_timestep=145,\n",
    "    line_at_predict_time=False,\n",
    "    title=\"Prediction results for a few sample time series\",\n",
    "    x_label=\"week\",\n",
    "    y_label=\"unit sales\",\n",
    "    random_seed=2,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional Reading\n",
    "\n",
    "\\[1\\] Rob J Hyndman and George Athanasopoulos. 2018. Forecasting: Principles and Practice. Chapter 8 ARIMA models: https://otexts.com/fpp2/arima.html <br>\n",
    "\n",
    "\\[2\\] Modern Parallel and Distributed Python: A Quick Tutorial on Ray: https://rise.cs.berkeley.edu/blog/modern-parallel-and-distributed-python-a-quick-tutorial-on-ray/ <br>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "forecasting_env",
   "language": "python",
   "name": "forecasting_env"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
